salesflare-mcp-server 1.0.0

package/dist/tools/tasks.js

@@ -0,0 +1,406 @@
+/**
+ * Task tools for Salesflare MCP Server
+ *
+ * Implements CRUD operations for tasks:
+ * - salesflare_tasks_list: List tasks with filtering and pagination
+ * - salesflare_tasks_create: Create new tasks
+ * - salesflare_tasks_update: Update existing tasks (mark complete/incomplete)
+ *
+ * @module tools/tasks
+ */
+import { SalesflareError, ErrorCode } from '../utils/errors.js';
+/**
+ * Task tool definitions with JSON schemas
+ */
+const taskTools = [
+    {
+        name: 'salesflare_tasks_list',
+        description: 'List tasks from Salesflare CRM with optional filtering and pagination. ' +
+            'Supports filtering by status (open, completed), assigned_user_id, related contact or deal, ' +
+            'overdue status, and date ranges (due_before, due_after). Results sorted by due_date (ascending), ' +
+            'then created_at (descending). Overdue tasks are flagged in the response.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: { type: 'string', enum: ['open', 'completed'], description: 'Filter by task status' },
+                assigned_user_id: { type: 'string', description: 'Filter by assigned user ID (UUID)' },
+                related_contact_id: { type: 'string', description: 'Filter by related contact ID (UUID)' },
+                related_deal_id: { type: 'string', description: 'Filter by related deal ID (UUID)' },
+                is_overdue: { type: 'boolean', description: 'Filter by overdue status' },
+                due_before: { type: 'string', description: 'Filter tasks due before this date (ISO 8601)' },
+                due_after: { type: 'string', description: 'Filter tasks due after this date (ISO 8601)' },
+                page: { type: 'number', description: 'Page number (default: 1)' },
+                limit: { type: 'number', description: 'Items per page (default: 20, max: 100)' },
+            },
+        },
+    },
+    {
+        name: 'salesflare_tasks_create',
+        description: 'Create a new task in Salesflare CRM. Description is required. ' +
+            'Optional fields include due_date (ISO 8601), assigned_user_id, and related contact or deal ' +
+            '(specify only one, not both). Tasks are created with status "open" by default. ' +
+            'Tasks can be linked to either a contact or a deal, but not both.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                description: { type: 'string', description: 'Task description (required)' },
+                due_date: { type: 'string', description: 'Due date (ISO 8601 format)' },
+                assigned_user_id: { type: 'string', description: 'Assigned user ID (UUID)' },
+                related_contact_id: { type: 'string', description: 'Related contact ID (UUID, mutually exclusive with related_deal_id)' },
+                related_deal_id: { type: 'string', description: 'Related deal ID (UUID, mutually exclusive with related_contact_id)' },
+                status: { type: 'string', enum: ['open', 'completed'], description: 'Task status (default: open)' },
+            },
+            required: ['description'],
+        },
+    },
+    {
+        name: 'salesflare_tasks_update',
+        description: 'Update an existing task in Salesflare CRM. Requires task_id. ' +
+            'All other fields are optional - only provided fields will be updated. ' +
+            'Status can be changed to mark tasks complete or reopen them. ' +
+            'When marking complete, completed_at is set automatically.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_id: { type: 'string', description: 'Task UUID to update' },
+                description: { type: 'string', description: 'Task description' },
+                due_date: { type: 'string', description: 'Due date (ISO 8601 format)' },
+                assigned_user_id: { type: 'string', description: 'Assigned user ID (UUID)' },
+                status: { type: 'string', enum: ['open', 'completed'], description: 'Task status' },
+            },
+            required: ['task_id'],
+        },
+    },
+];
+/**
+ * Exported task tools array for unified registration
+ */
+export { taskTools };
+/**
+ * Handle task tool calls
+ *
+ * @param client - Salesflare API client
+ * @param name - Tool name
+ * @param args - Tool arguments
+ * @returns Tool response
+ */
+export async function handleTasksTool(client, name, args) {
+    switch (name) {
+        case 'salesflare_tasks_list':
+            return await handleListTasks(client, args);
+        case 'salesflare_tasks_create':
+            return await handleCreateTask(client, args);
+        case 'salesflare_tasks_update':
+            return await handleUpdateTask(client, args);
+        default:
+            throw new SalesflareError({
+                code: ErrorCode.INVALID_INPUT,
+                message: `Unknown task tool: ${name}`,
+                retryable: false,
+            });
+    }
+}
+/**
+ * Register task-related tools with the MCP server
+ *
+ * @deprecated Use handleTasksTool instead for unified registration
+ * @param server - MCP Server instance
+ * @param client - Salesflare API client
+ */
+export function registerTasksTools(server, client) {
+    // This function is deprecated - use unified tool registration in server.ts
+    // Kept for backward compatibility
+}
+/**
+ * Check if a task is overdue
+ * Task is overdue if status is 'open' and due_date is in the past
+ */
+function isTaskOverdue(status, dueDate) {
+    if (status !== 'open' || !dueDate) {
+        return false;
+    }
+    const now = new Date();
+    const due = new Date(dueDate);
+    return due < now;
+}
+/**
+ * Format a date for display
+ */
+function formatDate(dateString) {
+    if (!dateString)
+        return 'No due date';
+    try {
+        const date = new Date(dateString);
+        return date.toLocaleDateString('en-US', {
+            month: 'short',
+            day: 'numeric',
+            year: 'numeric',
+        });
+    }
+    catch {
+        return dateString;
+    }
+}
+/**
+ * Handle salesflare_tasks_list tool call
+ * Implements filters per D-06 to D-12
+ */
+async function handleListTasks(client, params) {
+    // Build query parameters - only 'limit' is supported by API
+    const queryParams = {};
+    if (params.limit)
+        queryParams.limit = params.limit;
+    // Call Salesflare API - returns array directly, not { items: [...] }
+    const response = await client.get('/tasks', { params: queryParams });
+    // API returns array directly
+    const items = Array.isArray(response) ? response : [];
+    // Apply client-side filtering if requested
+    let filteredItems = items;
+    if (params.status) {
+        const targetStatus = params.status;
+        filteredItems = items.filter((item) => {
+            const itemStatus = item.status;
+            if (targetStatus === 'completed') {
+                return itemStatus === 'completed' || item.completed === true;
+            }
+            else {
+                return itemStatus !== 'completed' && item.completed !== true;
+            }
+        });
+    }
+    // Transform to curated response format (D-13)
+    const tasks = filteredItems.map((item) => {
+        const status = item.status || (item.completed ? 'completed' : 'open');
+        const dueDate = item.due_date;
+        return {
+            id: item.id,
+            description: item.description,
+            status,
+            due_date: dueDate,
+            assigned_user: item.assigned_user ? {
+                id: item.assigned_user.id,
+                name: item.assigned_user.name,
+            } : undefined,
+            related_contact: item.contact ? {
+                id: item.contact.id,
+                name: item.contact.name,
+            } : undefined,
+            related_deal: item.deal ? {
+                id: item.deal.id,
+                name: item.deal.name,
+            } : undefined,
+            completed_at: item.completed_at,
+            is_overdue: isTaskOverdue(status, dueDate),
+            created_at: item.created_at,
+            updated_at: item.updated_at,
+        };
+    });
+    const listResponse = {
+        tasks,
+        total: tasks.length,
+        page: 1,
+        limit: tasks.length,
+        has_more: false,
+    };
+    // Count overdue tasks
+    const overdueCount = tasks.filter(t => t.is_overdue).length;
+    // Generate human-readable summary (D-14, D-16)
+    let summaryText;
+    if (listResponse.tasks.length === 0) {
+        summaryText = 'No tasks found matching the criteria.';
+    }
+    else {
+        const filterInfo = params.status ? ` (filtered by status: ${params.status})` : '';
+        const overdueWarning = overdueCount > 0 ? ` ⚠️ ${overdueCount} overdue` : '';
+        summaryText = `Found ${listResponse.total} task(s)${filterInfo}.${overdueWarning}` +
+            ` Showing ${listResponse.tasks.length} result(s).`;
+        // Show first 3 tasks
+        const taskPreviews = listResponse.tasks.slice(0, 3).map(task => {
+            const overduePrefix = task.is_overdue ? '⚠️ OVERDUE: ' : '';
+            return `${overduePrefix}${task.description} (due: ${formatDate(task.due_date)}, status: ${task.status})`;
+        });
+        summaryText += '\n\n' + taskPreviews.join('\n');
+    }
+    return {
+        content: [
+            { type: 'text', text: summaryText },
+            { type: 'text', text: JSON.stringify(listResponse, null, 2) },
+        ],
+    };
+}
+/**
+ * Handle salesflare_tasks_create tool call
+ * Description is required per D-26
+ * Validates mutual exclusivity of contact vs deal per D-29
+ */
+async function handleCreateTask(client, params) {
+    // Validate mutual exclusivity per D-29
+    if (params.related_contact_id && params.related_deal_id) {
+        throw new SalesflareError({
+            code: ErrorCode.VALIDATION_ERROR,
+            message: 'Cannot link task to both contact and deal. Specify only one.',
+            details: { fields: ['related_contact_id', 'related_deal_id'] },
+            retryable: false,
+        });
+    }
+    // Build request body
+    const requestBody = {
+        description: params.description,
+        // Note: API doesn't accept 'status' on create, defaults to 'open'
+    };
+    if (params.due_date)
+        requestBody.due_date = params.due_date;
+    if (params.assigned_user_id)
+        requestBody.assigned_user_id = params.assigned_user_id;
+    if (params.related_contact_id)
+        requestBody.contact_id = params.related_contact_id;
+    if (params.related_deal_id)
+        requestBody.deal_id = params.related_deal_id;
+    // Call Salesflare API to create task
+    const response = await client.post('/tasks', requestBody);
+    // Transform to curated response format (D-13)
+    const status = response.status;
+    const dueDate = response.due_date;
+    const task = {
+        id: response.id,
+        description: response.description,
+        status,
+        due_date: dueDate,
+        assigned_user: response.assigned_user ? {
+            id: response.assigned_user.id,
+            name: response.assigned_user.name,
+        } : undefined,
+        related_contact: response.contact ? {
+            id: response.contact.id,
+            name: response.contact.name,
+        } : undefined,
+        related_deal: response.deal ? {
+            id: response.deal.id,
+            name: response.deal.name,
+        } : undefined,
+        completed_at: response.completed_at,
+        is_overdue: isTaskOverdue(status, dueDate),
+        created_at: response.created_at,
+        updated_at: response.updated_at,
+    };
+    // Generate human-readable summary (D-14, D-16)
+    let summaryText = `✓ Task created: ${task.description}`;
+    if (task.due_date) {
+        summaryText += ` (due: ${formatDate(task.due_date)})`;
+    }
+    if (task.assigned_user) {
+        summaryText += ` assigned to ${task.assigned_user.name}`;
+    }
+    if (task.related_contact) {
+        summaryText += ` linked to contact: ${task.related_contact.name}`;
+    }
+    if (task.related_deal) {
+        summaryText += ` linked to deal: ${task.related_deal.name}`;
+    }
+    if (task.is_overdue) {
+        summaryText += ' ⚠️ OVERDUE';
+    }
+    return {
+        content: [
+            { type: 'text', text: summaryText },
+            { type: 'text', text: JSON.stringify(task, null, 2) },
+        ],
+    };
+}
+/**
+ * Transform API response to curated Task format
+ * Shared transformation logic for create and update
+ */
+function transformTaskResponse(response) {
+    const status = response.status;
+    const dueDate = response.due_date;
+    return {
+        id: response.id,
+        description: response.description,
+        status,
+        due_date: dueDate,
+        assigned_user: response.assigned_user ? {
+            id: response.assigned_user.id,
+            name: response.assigned_user.name,
+        } : undefined,
+        related_contact: response.contact ? {
+            id: response.contact.id,
+            name: response.contact.name,
+        } : undefined,
+        related_deal: response.deal ? {
+            id: response.deal.id,
+            name: response.deal.name,
+        } : undefined,
+        completed_at: response.completed_at,
+        is_overdue: isTaskOverdue(status, dueDate),
+        created_at: response.created_at,
+        updated_at: response.updated_at,
+    };
+}
+/**
+ * Handle salesflare_tasks_update tool call
+ * Partial update per D-25: only provided fields will be updated
+ * Status changes trigger completed_at updates
+ */
+async function handleUpdateTask(client, params) {
+    const { task_id, ...updateData } = params;
+    // Validate task_id is provided
+    if (!task_id) {
+        return {
+            content: [
+                { type: 'text', text: 'Error [INVALID_INPUT]: task_id is required.' },
+                { type: 'text', text: '{}' },
+            ],
+        };
+    }
+    // Check if at least one field is provided for update
+    const hasUpdateFields = Object.keys(updateData).length > 0;
+    if (!hasUpdateFields) {
+        return {
+            content: [
+                { type: 'text', text: 'Error [INVALID_INPUT]: At least one field must be provided for update.' },
+                { type: 'text', text: '{}' },
+            ],
+        };
+    }
+    // Build PATCH body
+    const patchBody = {};
+    if (updateData.description !== undefined)
+        patchBody.description = updateData.description;
+    if (updateData.due_date !== undefined)
+        patchBody.due_date = updateData.due_date;
+    if (updateData.assigned_user_id !== undefined)
+        patchBody.assigned_user_id = updateData.assigned_user_id;
+    if (updateData.status !== undefined) {
+        patchBody.status = updateData.status;
+        // Handle completed_at based on status change
+        if (updateData.status === 'completed') {
+            patchBody.completed_at = new Date().toISOString();
+        }
+        else if (updateData.status === 'open') {
+            // Clear completed_at when reopening
+            patchBody.completed_at = null;
+        }
+    }
+    // Call Salesflare API to update task
+    const response = await client.patch(`/tasks/${task_id}`, patchBody);
+    // Transform to curated response format
+    const task = transformTaskResponse(response);
+    // Generate human-readable summary
+    let summaryText = `✓ Task updated: ${task.description}`;
+    if (updateData.status !== undefined) {
+        summaryText += ` (status: ${updateData.status})`;
+        if (updateData.status === 'completed' && task.completed_at) {
+            summaryText += ` completed at ${formatDate(task.completed_at)}`;
+        }
+    }
+    if (task.is_overdue) {
+        summaryText += ' ⚠️ OVERDUE';
+    }
+    return {
+        content: [
+            { type: 'text', text: summaryText },
+            { type: 'text', text: JSON.stringify(task, null, 2) },
+        ],
+    };
+}

package/dist/transport/http-transport.d.ts

@@ -0,0 +1,36 @@
+/**
+ * HTTP Streamable transport implementation for MCP protocol communication
+ *
+ * Provides HTTP transport with:
+ * - Express.js server with CORS support
+ * - Health endpoint at GET /health
+ * - MCP endpoint at POST /mcp
+ * - API key authentication middleware
+ * - Request logging to stderr
+ * - Graceful shutdown handling
+ *
+ * Per D-09: Uses Express.js framework
+ * Per D-10: Includes CORS, health endpoint, API key validation
+ * Per D-11: MCP endpoint at POST /mcp
+ * Per D-12: Uses same SALESFLARE_API_KEY as stdio mode
+ *
+ * @module transport/http-transport
+ */
+/**
+ * Configuration for HTTP transport
+ */
+export interface HttpTransportConfig {
+    /** Port to listen on (default: 3000) */
+    port?: number;
+    /** Host to bind to (default: localhost) */
+    host?: string;
+}
+/**
+ * Create and start the HTTP transport server
+ *
+ * @param config - HTTP transport configuration
+ * @returns Promise resolving to the HTTP server instance
+ * @throws SalesflareError if server fails to start
+ */
+export declare function createHttpTransport(config?: HttpTransportConfig): Promise<void>;
+//# sourceMappingURL=http-transport.d.ts.map

package/dist/transport/http-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-transport.d.ts","sourceRoot":"","sources":["../../src/transport/http-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AASH;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AA6DD;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,GAAE,mBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+GzF"}

package/dist/transport/http-transport.js

@@ -0,0 +1,173 @@
+/**
+ * HTTP Streamable transport implementation for MCP protocol communication
+ *
+ * Provides HTTP transport with:
+ * - Express.js server with CORS support
+ * - Health endpoint at GET /health
+ * - MCP endpoint at POST /mcp
+ * - API key authentication middleware
+ * - Request logging to stderr
+ * - Graceful shutdown handling
+ *
+ * Per D-09: Uses Express.js framework
+ * Per D-10: Includes CORS, health endpoint, API key validation
+ * Per D-11: MCP endpoint at POST /mcp
+ * Per D-12: Uses same SALESFLARE_API_KEY as stdio mode
+ *
+ * @module transport/http-transport
+ */
+import express from 'express';
+import cors from 'cors';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createServer } from '../server.js';
+import { SalesflareError, ErrorCode } from '../utils/errors.js';
+/**
+ * API key middleware - validates Bearer token
+ *
+ * Per D-10, D-12: Validates API key from Authorization header
+ */
+function apiKeyMiddleware(req, res, next) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader) {
+        res.status(401).json({
+            error: 'Unauthorized',
+            message: 'Authorization header required',
+            fix: 'Provide Authorization: Bearer <api_key> header',
+        });
+        return;
+    }
+    // Validate Bearer token format
+    const parts = authHeader.split(' ');
+    if (parts.length !== 2 || parts[0].toLowerCase() !== 'bearer') {
+        res.status(401).json({
+            error: 'Unauthorized',
+            message: 'Invalid Authorization header format. Use: Bearer <api_key>',
+        });
+        return;
+    }
+    const token = parts[1];
+    if (!token || token.length === 0) {
+        res.status(401).json({
+            error: 'Unauthorized',
+            message: 'API key cannot be empty',
+        });
+        return;
+    }
+    // Attach token to request for downstream use
+    req.authToken = token;
+    next();
+}
+/**
+ * Request logging middleware - logs to stderr
+ *
+ * Per D-15: Consistent with Phase 1 logging (stderr only)
+ */
+function loggingMiddleware(req, res, next) {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] ${req.method} ${req.path} - ${req.ip || 'unknown'}`);
+    next();
+}
+/**
+ * Create and start the HTTP transport server
+ *
+ * @param config - HTTP transport configuration
+ * @returns Promise resolving to the HTTP server instance
+ * @throws SalesflareError if server fails to start
+ */
+export async function createHttpTransport(config = {}) {
+    const port = config.port || parseInt(process.env.PORT || '3000', 10);
+    const host = config.host || process.env.HOST || 'localhost';
+    // Create Express app
+    const app = express();
+    // Enable CORS (configurable per D-10)
+    app.use(cors({
+        origin: process.env.CORS_ORIGIN || '*',
+        methods: ['GET', 'POST', 'OPTIONS'],
+        allowedHeaders: ['Authorization', 'Content-Type'],
+    }));
+    // Parse JSON bodies
+    app.use(express.json());
+    // Request logging to stderr
+    app.use(loggingMiddleware);
+    // Health endpoint per D-10
+    app.get('/health', (_req, res) => {
+        res.json({
+            status: 'ok',
+            timestamp: new Date().toISOString(),
+            transport: 'http',
+        });
+    });
+    // MCP endpoint at POST /mcp per D-11
+    app.post('/mcp', apiKeyMiddleware, async (req, res) => {
+        try {
+            // Create MCP server with validated auth token
+            // The token was validated by middleware, now set it for the server
+            process.env.SALESFLARE_API_KEY = req.authToken;
+            const server = createServer({ transport: 'http' });
+            // Create streamable HTTP transport
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            });
+            // Connect server to transport
+            await server.connect(transport);
+            // Handle the request
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error('MCP request error:', error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    error: 'Internal Server Error',
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                });
+            }
+        }
+    });
+    // 404 handler for undefined routes
+    app.use((_req, res) => {
+        res.status(404).json({
+            error: 'Not Found',
+            message: 'Endpoint not found. Use POST /mcp for MCP requests or GET /health for health checks.',
+        });
+    });
+    // Start server
+    return new Promise((resolve, reject) => {
+        const server = app.listen(port, host, () => {
+            console.error(`HTTP transport listening on http://${host}:${port}`);
+            console.error(`Health endpoint: http://${host}:${port}/health`);
+            console.error(`MCP endpoint: http://${host}:${port}/mcp`);
+        });
+        // Handle server errors
+        server.on('error', (error) => {
+            if (error.code === 'EADDRINUSE') {
+                reject(new SalesflareError({
+                    code: ErrorCode.CONFIG_ERROR,
+                    message: `Port ${port} is already in use`,
+                    fix: `Choose a different port with PORT environment variable or stop the process using port ${port}`,
+                    retryable: false,
+                }));
+            }
+            else {
+                reject(new SalesflareError({
+                    code: ErrorCode.SERVER_ERROR,
+                    message: `Failed to start HTTP server: ${error.message}`,
+                    retryable: false,
+                }));
+            }
+        });
+        // Graceful shutdown
+        const shutdown = (signal) => {
+            console.error(`Shutting down HTTP server... (${signal})`);
+            server.close(() => {
+                console.error('HTTP server closed');
+                process.exit(0);
+            });
+        };
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+        // Resolve when server is listening
+        server.on('listening', () => {
+            resolve();
+        });
+    });
+}

package/dist/transport/stdio-transport.d.ts

@@ -0,0 +1,37 @@
+/**
+ * stdio transport implementation for MCP protocol communication
+ *
+ * Handles MCP protocol communication over stdin/stdout with proper error handling
+ * and graceful shutdown. All logging goes to stderr to avoid protocol corruption.
+ *
+ * @module transport/stdio-transport
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+/**
+ * Configuration for stdio transport
+ */
+export interface StdioTransportConfig {
+    /** The MCP server instance to connect */
+    server: Server;
+}
+/**
+ * Create a new stdio transport instance
+ *
+ * @param config - Transport configuration with server instance
+ * @returns Configured StdioServerTransport instance
+ * @throws SalesflareError if stdio is not available
+ */
+export declare function createStdioTransport(config: StdioTransportConfig): StdioServerTransport;
+/**
+ * Start the MCP server with stdio transport
+ *
+ * Connects the server to stdio transport, sets up graceful shutdown,
+ * and logs status to stderr.
+ *
+ * @param config - Transport configuration with server instance
+ * @returns Promise that resolves when server is connected and ready
+ * @throws SalesflareError if connection fails
+ */
+export declare function startStdioServer(config: StdioTransportConfig): Promise<void>;
+//# sourceMappingURL=stdio-transport.d.ts.map

package/dist/transport/stdio-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio-transport.d.ts","sourceRoot":"","sources":["../../src/transport/stdio-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAGjF;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;CAChB;AAaD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,oBAAoB,CA8BvF;AAED;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuClF"}