@martin4455/redmine-mcp-ro 0.3.0

package/dist/server.js

@@ -0,0 +1,222 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { RedmineClient } from './redmine-client.js';
+import { UserResolver } from './user-resolver.js';
+import { AttachmentDownloader } from './attachment-downloader.js';
+import { AttachmentParser } from './attachment-parser.js';
+import { tools } from './tool-definitions.js';
+import { ToolArgumentValidator } from './tool-validation.js';
+import { safeErrorMessage } from './safe-error.js';
+import { stripApiKeys } from './api-key-filter.js';
+export async function startServer(redmineConfig) {
+    // Initialize Redmine client
+    const redmineClient = new RedmineClient(redmineConfig);
+    // Initialize user resolver
+    const userResolver = new UserResolver(redmineClient);
+    // Initialize attachment downloader
+    const attachmentDownloader = new AttachmentDownloader(redmineConfig);
+    // Initialize attachment parser
+    const attachmentParser = new AttachmentParser();
+    // Create MCP server
+    const server = new Server({
+        name: 'redmine-mcp-ro',
+        version: '0.3.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    const toolValidator = new ToolArgumentValidator(tools);
+    // Handle list tools request
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools };
+    });
+    // Handle tool execution
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: input = {} } = request.params;
+        try {
+            const args = toolValidator.validate(name, input);
+            let result;
+            switch (name) {
+                case 'list_issues': {
+                    // Resolve assigned_to_id if it's a string (name or email)
+                    const params = { ...args };
+                    if (params.assigned_to_id) {
+                        params.assigned_to_id = await userResolver.resolveUser(params.assigned_to_id);
+                    }
+                    result = await redmineClient.getIssues(params);
+                    break;
+                }
+                case 'get_issue': {
+                    const issueData = await redmineClient.getIssue(args.id, args.include);
+                    // If attachments or journals are included, enhance with embedded attachments
+                    if (args.include?.includes('attachments') || args.include?.includes('journals')) {
+                        const embeddedAttachments = attachmentParser.findAllAttachments(issueData, redmineConfig.url);
+                        // Add embedded_attachments field if we found any
+                        if (embeddedAttachments.length > 0) {
+                            // Mark which attachments are from API vs embedded
+                            if (issueData.attachments) {
+                                const apiIds = new Set(issueData.attachments.map((a) => a.id));
+                                issueData.embedded_attachments = embeddedAttachments.map((att) => ({
+                                    ...att,
+                                    source: apiIds.has(att.id) ? 'api' : 'embedded'
+                                }));
+                            }
+                            else {
+                                issueData.embedded_attachments = embeddedAttachments.map((att) => ({
+                                    ...att,
+                                    source: 'embedded'
+                                }));
+                            }
+                        }
+                    }
+                    result = issueData;
+                    break;
+                }
+                case 'list_projects':
+                    result = await redmineClient.getProjects(args);
+                    break;
+                case 'get_project':
+                    result = await redmineClient.getProject(args.id, args.include);
+                    break;
+                case 'list_users':
+                    result = await redmineClient.getUsers(args);
+                    break;
+                case 'get_user':
+                    result = await redmineClient.getUser(args.id, args.include);
+                    break;
+                case 'get_current_user':
+                    result = await redmineClient.getCurrentUser();
+                    break;
+                case 'list_time_entries':
+                    result = await redmineClient.getTimeEntries(args);
+                    break;
+                case 'get_time_entry':
+                    result = await redmineClient.getTimeEntry(args.id);
+                    break;
+                case 'list_project_versions':
+                    result = await redmineClient.getProjectVersions(args.project_id);
+                    break;
+                case 'get_version':
+                    result = await redmineClient.getVersion(args.id);
+                    break;
+                case 'list_news':
+                    if (args.project_id) {
+                        result = await redmineClient.getProjectNews(args.project_id, args);
+                    }
+                    else {
+                        result = await redmineClient.getNews(args);
+                    }
+                    break;
+                case 'list_wiki_pages':
+                    result = await redmineClient.getWikiPages(args.project_id);
+                    break;
+                case 'get_wiki_page':
+                    result = await redmineClient.getWikiPage(args.project_id, args.title, args.version);
+                    break;
+                case 'list_project_memberships':
+                    result = await redmineClient.getProjectMemberships(args.project_id, args);
+                    break;
+                case 'get_membership':
+                    result = await redmineClient.getMembership(args.id);
+                    break;
+                case 'list_issue_statuses':
+                    result = await redmineClient.getIssueStatuses();
+                    break;
+                case 'list_trackers':
+                    result = await redmineClient.getTrackers();
+                    break;
+                case 'list_issue_priorities':
+                    result = await redmineClient.getIssuePriorities();
+                    break;
+                case 'list_time_entry_activities':
+                    result = await redmineClient.getTimeEntryActivities();
+                    break;
+                case 'list_roles':
+                    result = await redmineClient.getRoles();
+                    break;
+                case 'get_role':
+                    result = await redmineClient.getRole(args.id);
+                    break;
+                case 'list_groups':
+                    result = await redmineClient.getGroups(args);
+                    break;
+                case 'get_group':
+                    result = await redmineClient.getGroup(args.id, args.include);
+                    break;
+                case 'list_custom_fields':
+                    result = await redmineClient.getCustomFields();
+                    break;
+                case 'search':
+                    result = await redmineClient.search(args.query, args);
+                    break;
+                case 'list_project_issue_categories':
+                    result = await redmineClient.getProjectIssueCategories(args.project_id);
+                    break;
+                case 'get_issue_category':
+                    result = await redmineClient.getIssueCategory(args.id);
+                    break;
+                case 'get_attachment':
+                    result = await redmineClient.getAttachment(args.id);
+                    break;
+                case 'list_issue_relations':
+                    result = await redmineClient.getIssueRelations(args.issue_id);
+                    break;
+                case 'get_relation':
+                    result = await redmineClient.getRelation(args.id);
+                    break;
+                case 'list_queries':
+                    result = await redmineClient.getQueries(args);
+                    break;
+                case 'list_project_files':
+                    result = await redmineClient.getProjectFiles(args.project_id);
+                    break;
+                case 'download_attachment':
+                    result = await attachmentDownloader.downloadAttachment(args.attachment_id, args.output_dir, {
+                        version: args.version,
+                        timestamp: args.timestamp,
+                    });
+                    break;
+                case 'download_issue_attachments':
+                    result = await attachmentDownloader.downloadAllIssueAttachments(args.issue_id, args.output_dir, true // Include embedded attachments
+                    );
+                    break;
+                case 'get_attachment_content':
+                    result = await attachmentDownloader.getAttachmentContent(args.attachment_id);
+                    break;
+                default:
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Unknown tool: ${name}`,
+                            },
+                        ],
+                    };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(stripApiKeys(result), null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${safeErrorMessage(error, [redmineConfig.apiKey])}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Redmine MCP server started successfully');
+}

package/dist/tool-definitions.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const tools: Tool[];

package/dist/tool-definitions.js

@@ -0,0 +1,460 @@
+// Define available tools
+export const tools = [
+    {
+        name: 'list_issues',
+        description: 'List and search Redmine issues with optional filters',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                project_id: { type: 'string', minLength: 1, maxLength: 4096, pattern: '^[a-zA-Z0-9_-]+$', description: 'Project ID or identifier' },
+                status_id: { type: 'string', minLength: 1, maxLength: 4096, description: 'Status ID or name (open, closed, *)' },
+                assigned_to_id: { type: 'string', minLength: 1, maxLength: 4096, description: 'User ID, name (First Last), email, "me"/"current" for current user' },
+                tracker_id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Tracker ID' },
+                query_id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Query ID' },
+                offset: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: 'Offset for pagination' },
+                limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Limit for pagination (max 100)' },
+                sort: { type: 'string', minLength: 1, maxLength: 4096, description: 'Sort order' },
+            },
+        },
+    },
+    {
+        name: 'get_issue',
+        description: 'Get details of a specific Redmine issue. When including "attachments" or "journals", also finds attachments embedded in HTML descriptions and comments.',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Issue ID' },
+                include: {
+                    type: 'array', maxItems: 20, uniqueItems: true,
+                    items: { type: 'string', minLength: 1, maxLength: 4096 },
+                    description: 'Additional data to include (children, attachments, relations, changesets, journals, watchers). Including "attachments" or "journals" will also find embedded attachments in HTML.',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_projects',
+        description: 'List all Redmine projects',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                offset: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: 'Offset for pagination' },
+                limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Limit for pagination' },
+            },
+        },
+    },
+    {
+        name: 'get_project',
+        description: 'Get details of a specific Redmine project',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'string', minLength: 1, maxLength: 4096, pattern: '^[a-zA-Z0-9_-]+$', description: 'Project ID or identifier' },
+                include: {
+                    type: 'array', maxItems: 20, uniqueItems: true,
+                    items: { type: 'string', minLength: 1, maxLength: 4096 },
+                    description: 'Additional data to include (trackers, issue_categories, enabled_modules)',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_users',
+        description: 'List Redmine users (requires admin permissions)',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                offset: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: 'Offset for pagination' },
+                limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Limit for pagination' },
+            },
+        },
+    },
+    {
+        name: 'get_user',
+        description: 'Get details of a specific Redmine user',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'User ID' },
+                include: {
+                    type: 'array', maxItems: 20, uniqueItems: true,
+                    items: { type: 'string', minLength: 1, maxLength: 4096 },
+                    description: 'Additional data to include (memberships, groups)',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'get_current_user',
+        description: 'Get details of the current authenticated user',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {},
+        },
+    },
+    {
+        name: 'list_time_entries',
+        description: 'List time entries',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                project_id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Project ID' },
+                user_id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'User ID' },
+                offset: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: 'Offset for pagination' },
+                limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Limit for pagination' },
+            },
+        },
+    },
+    {
+        name: 'get_time_entry',
+        description: 'Get details of a specific time entry',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Time entry ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_project_versions',
+        description: 'List versions for a project',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                project_id: { type: 'string', minLength: 1, maxLength: 4096, pattern: '^[a-zA-Z0-9_-]+$', description: 'Project ID or identifier' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'get_version',
+        description: 'Get details of a specific version',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Version ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_news',
+        description: 'List news items',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                project_id: { type: 'string', minLength: 1, maxLength: 4096, pattern: '^[a-zA-Z0-9_-]+$', description: 'Project ID or identifier (optional)' },
+                offset: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: 'Offset for pagination' },
+                limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Limit for pagination' },
+            },
+        },
+    },
+    {
+        name: 'list_wiki_pages',
+        description: 'List wiki pages for a project',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                project_id: { type: 'string', minLength: 1, maxLength: 4096, pattern: '^[a-zA-Z0-9_-]+$', description: 'Project ID or identifier' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'get_wiki_page',
+        description: 'Get content of a specific wiki page',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                project_id: { type: 'string', minLength: 1, maxLength: 4096, pattern: '^[a-zA-Z0-9_-]+$', description: 'Project ID or identifier' },
+                title: { type: 'string', minLength: 1, maxLength: 4096, description: 'Wiki page title' },
+                version: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Page version (optional)' },
+            },
+            required: ['project_id', 'title'],
+        },
+    },
+    {
+        name: 'list_project_memberships',
+        description: 'List memberships for a project',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                project_id: { type: 'string', minLength: 1, maxLength: 4096, pattern: '^[a-zA-Z0-9_-]+$', description: 'Project ID or identifier' },
+                offset: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: 'Offset for pagination' },
+                limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Limit for pagination' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'get_membership',
+        description: 'Get details of a specific membership',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Membership ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_issue_statuses',
+        description: 'List all available issue statuses',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {},
+        },
+    },
+    {
+        name: 'list_trackers',
+        description: 'List all available issue trackers',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {},
+        },
+    },
+    {
+        name: 'list_issue_priorities',
+        description: 'List all available issue priorities',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {},
+        },
+    },
+    {
+        name: 'list_time_entry_activities',
+        description: 'List all available time entry activities',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {},
+        },
+    },
+    {
+        name: 'list_roles',
+        description: 'List all available roles',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {},
+        },
+    },
+    {
+        name: 'get_role',
+        description: 'Get details of a specific role',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Role ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_groups',
+        description: 'List all groups (requires admin permissions)',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                offset: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: 'Offset for pagination' },
+                limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Limit for pagination' },
+            },
+        },
+    },
+    {
+        name: 'get_group',
+        description: 'Get details of a specific group',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Group ID' },
+                include: {
+                    type: 'array', maxItems: 20, uniqueItems: true,
+                    items: { type: 'string', minLength: 1, maxLength: 4096 },
+                    description: 'Additional data to include (users, memberships)',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_custom_fields',
+        description: 'List all custom field definitions',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {},
+        },
+    },
+    {
+        name: 'search',
+        description: 'Search across Redmine resources',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                query: { type: 'string', minLength: 1, maxLength: 4096, description: 'Search query' },
+                issues: { type: 'boolean', description: 'Search in issues' },
+                news: { type: 'boolean', description: 'Search in news' },
+                documents: { type: 'boolean', description: 'Search in documents' },
+                changesets: { type: 'boolean', description: 'Search in changesets' },
+                wiki_pages: { type: 'boolean', description: 'Search in wiki pages' },
+                messages: { type: 'boolean', description: 'Search in messages' },
+                projects: { type: 'boolean', description: 'Search in projects' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'list_project_issue_categories',
+        description: 'List issue categories for a project',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                project_id: { type: 'string', minLength: 1, maxLength: 4096, pattern: '^[a-zA-Z0-9_-]+$', description: 'Project ID or identifier' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'get_issue_category',
+        description: 'Get details of a specific issue category',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Issue category ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'get_attachment',
+        description: 'Get details of a specific attachment',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Attachment ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_issue_relations',
+        description: 'List relations for an issue',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                issue_id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Issue ID' },
+            },
+            required: ['issue_id'],
+        },
+    },
+    {
+        name: 'get_relation',
+        description: 'Get details of a specific issue relation',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Relation ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_queries',
+        description: 'List saved queries',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                offset: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: 'Offset for pagination' },
+                limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Limit for pagination' },
+            },
+        },
+    },
+    {
+        name: 'list_project_files',
+        description: 'List files for a project',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                project_id: { type: 'string', minLength: 1, maxLength: 4096, pattern: '^[a-zA-Z0-9_-]+$', description: 'Project ID or identifier' },
+            },
+            required: ['project_id'],
+        },
+    },
+    {
+        name: 'download_attachment',
+        description: 'Save an attachment inside the operator-configured download directory. Disabled until a download directory is configured.',
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                attachment_id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Attachment ID' },
+                output_dir: { type: 'string', minLength: 1, maxLength: 4096, description: 'Optional relative subdirectory of the configured download directory; defaults to its root. Absolute paths, parent traversal and symlinks are rejected.' },
+                version: { type: 'boolean', description: 'Include version parameter (for Easy Redmine)' },
+                timestamp: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Timestamp parameter (for Easy Redmine)' },
+            },
+            required: ['attachment_id'],
+        },
+    },
+    {
+        name: 'download_issue_attachments',
+        description: 'Save issue attachments, including embedded attachments, inside the operator-configured download directory. Disabled until a download directory is configured.',
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                issue_id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Issue ID' },
+                output_dir: { type: 'string', minLength: 1, maxLength: 4096, description: 'Optional relative subdirectory of the configured download directory; defaults to its root. Absolute paths, parent traversal and symlinks are rejected.' },
+            },
+            required: ['issue_id'],
+        },
+    },
+    {
+        name: 'get_attachment_content',
+        description: 'Get attachment content as base64 (for smaller files)',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                attachment_id: { type: 'integer', minimum: 1, maximum: Number.MAX_SAFE_INTEGER, description: 'Attachment ID' },
+            },
+            required: ['attachment_id'],
+        },
+    },
+];