MCP Go High Level Integration: The Ultimate Developer’s Guide to Context-Aware Marketing Automation

# GoHighLevel API Configuration
GOHIGHLEVEL_API_KEY=your_api_key_here
GOHIGHLEVEL_API_URL=https://rest.gohighlevel.com/v1
GOHIGHLEVEL_LOCATION_ID=your_location_id

# MCP Server Configuration
MCP_SERVER_PORT=3000
MCP_SERVER_NAME=gohighlevel-mcp-server
MCP_LOG_LEVEL=debug

# Security Settings
JWT_SECRET=your_jwt_secret_for_authentication
ALLOWED_ORIGINS=http://localhost:3000,https://yourdomain.com

npm init -y
npm install @modelcontextprotocol/sdk axios dotenv
npm install --save-dev typescript @types/node ts-node
npx tsc --init

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import axios from 'axios';
import dotenv from 'dotenv';

dotenv.config();

class GoHighLevelMCPServer {
    private server: Server;
    private axiosInstance: any;

    constructor() {
        this.server = new Server({
            name: process.env.MCP_SERVER_NAME || 'gohighlevel-mcp',
            version: '1.0.0'
        }, {
            capabilities: {
                resources: {},
                tools: {}
            }
        });

        this.axiosInstance = axios.create({
            baseURL: process.env.GOHIGHLEVEL_API_URL,
            headers: {
                'Authorization': `Bearer ${process.env.GOHIGHLEVEL_API_KEY}`,
                'Content-Type': 'application/json'
            }
        });

        this.setupHandlers();
    }

    private setupHandlers() {
        // List available resources
        this.server.setRequestHandler('resources/list', async () => ({
            resources: [
                {
                    uri: 'ghl://contacts',
                    name: 'GoHighLevel Contacts',
                    description: 'Access and manage CRM contacts',
                    mimeType: 'application/json'
                },
                {
                    uri: 'ghl://opportunities',
                    name: 'Sales Opportunities',
                    description: 'View and manage sales pipeline',
                    mimeType: 'application/json'
                }
            ]
        }));

        // Read resource content
        this.server.setRequestHandler('resources/read', async (request) => {
            const uri = request.params.uri as string;
            
            if (uri === 'ghl://contacts') {
                const contacts = await this.fetchContacts();
                return {
                    contents: [{
                        uri,
                        mimeType: 'application/json',
                        text: JSON.stringify(contacts, null, 2)
                    }]
                };
            }
            
            throw new Error(`Unknown resource: ${uri}`);
        });

        // List available tools
        this.server.setRequestHandler('tools/list', async () => ({
            tools: [
                {
                    name: 'create_contact',
                    description: 'Create a new contact in GoHighLevel CRM',
                    inputSchema: {
                        type: 'object',
                        properties: {
                            email: { type: 'string' },
                            name: { type: 'string' },
                            phone: { type: 'string' },
                            tags: { type: 'array', items: { type: 'string' } }
                        },
                        required: ['email', 'name']
                    }
                },
                {
                    name: 'trigger_workflow',
                    description: 'Trigger a GoHighLevel workflow for a contact',
                    inputSchema: {
                        type: 'object',
                        properties: {
                            contactId: { type: 'string' },
                            workflowId: { type: 'string' }
                        },
                        required: ['contactId', 'workflowId']
                    }
                }
            ]
        }));

        // Execute tools
        this.server.setRequestHandler('tools/call', async (request) => {
            const { name, arguments: args } = request.params;

            if (name === 'create_contact') {
                return await this.createContact(args);
            } else if (name === 'trigger_workflow') {
                return await this.triggerWorkflow(args);
            }

            throw new Error(`Unknown tool: ${name}`);
        });
    }

    private async fetchContacts() {
        try {
            const response = await this.axiosInstance.get('/contacts', {
                params: {
                    locationId: process.env.GOHIGHLEVEL_LOCATION_ID,
                    limit: 100
                }
            });
            return response.data.contacts;
        } catch (error) {
            console.error('Error fetching contacts:', error);
            throw error;
        }
    }

    private async createContact(args: any) {
        try {
            const response = await this.axiosInstance.post('/contacts', {
                locationId: process.env.GOHIGHLEVEL_LOCATION_ID,
                ...args
            });
            
            return {
                content: [{
                    type: 'text',
                    text: `Contact created successfully with ID: ${response.data.contact.id}`
                }]
            };
        } catch (error) {
            console.error('Error creating contact:', error);
            return {
                content: [{
                    type: 'text',
                    text: `Failed to create contact: ${error.message}`
                }
], isError: true
};
}
}
private async triggerWorkflow(args: any) {
    try {
        const response = await this.axiosInstance.post(
            `/contacts/${args.contactId}/workflow/${args.workflowId}`,
            {
                locationId: process.env.GOHIGHLEVEL_LOCATION_ID
            }
        );
        
        return {
            content: [{
                type: 'text',
                text: `Workflow triggered successfully for contact ${args.contactId}`
            }]
        };
    } catch (error) {
        console.error('Error triggering workflow:', error);
        return {
            content: [{
                type: 'text',
                text: `Failed to trigger workflow: ${error.message}`
            }],
            isError: true
        };
    }
}

async start() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.log('GoHighLevel MCP Server running on stdio');
}
}
// Start the server
const server = new GoHighLevelMCPServer();
server.start().catch(console.error);

import express from 'express';
import crypto from 'crypto';
class WebhookManager {
private app: express.Application;
private contextCache: Map;
constructor() {
    this.app = express();
    this.contextCache = new Map();
    this.setupWebhookEndpoints();
}

private verifyWebhookSignature(payload: string, signature: string): boolean {
    const webhookSecret = process.env.GOHIGHLEVEL_WEBHOOK_SECRET;
    const expectedSignature = crypto
        .createHmac('sha256', webhookSecret)
        .update(payload)
        .digest('hex');
    
    return crypto.timingSafeEqual(
        Buffer.from(signature),
        Buffer.from(expectedSignature)
    );
}

private setupWebhookEndpoints() {
    this.app.use(express.json());

    this.app.post('/webhooks/ghl/contact-created', async (req, res) => {
        const signature = req.headers['x-ghl-signature'] as string;
        const payload = JSON.stringify(req.body);

        if (!this.verifyWebhookSignature(payload, signature)) {
            return res.status(401).json({ error: 'Invalid signature' });
        }

        const contactData = req.body;
        
        // Update context cache for immediate MCP access
        this.contextCache.set(
            `contact:${contactData.id}`,
            {
                ...contactData,
                lastUpdated: new Date().toISOString(),
                source: 'webhook'
            }
        );

        // Trigger any configured automations
        await this.processContactCreation(contactData);

        res.status(200).json({ received: true });
    });

    this.app.post('/webhooks/ghl/opportunity-status', async (req, res) => {
        const signature = req.headers['x-ghl-signature'] as string;
        const payload = JSON.stringify(req.body);

        if (!this.verifyWebhookSignature(payload, signature)) {
            return res.status(401).json({ error: 'Invalid signature' });
        }

        const opportunityData = req.body;
        
        // Update opportunity context
        this.contextCache.set(
            `opportunity:${opportunityData.id}`,
            {
                ...opportunityData,
                statusChanged: true,
                timestamp: new Date().toISOString()
            }
        );

        // Notify MCP clients of context change
        await this.broadcastContextUpdate('opportunity', opportunityData.id);

        res.status(200).json({ received: true });
    });
}

private async processContactCreation(contactData: any) {
    // Example: Automatically tag high-value contacts
    if (contactData.customFields?.estimatedValue > 10000) {
        console.log(`High-value contact detected: ${contactData.email}`);
        // Trigger specific workflows or notifications
    }
}

private async broadcastContextUpdate(type: string, id: string) {
    // Implement SSE or WebSocket broadcasting to connected MCP clients
    console.log(`Context updated: ${type}:${id}`);
}

getContext(key: string): any {
    return this.contextCache.get(key);
}

start(port: number = 3001) {
    this.app.listen(port, () => {
        console.log(`Webhook server listening on port ${port}`);
    });
}
}
export default WebhookManager;

class RateLimiter {
private tokens: number;
private maxTokens: number;
private refillRate: number;
private lastRefill: number;

constructor(requestsPerSecond: number = 2) {
    this.maxTokens = requestsPerSecond * 10;
    this.tokens = this.maxTokens;
    this.refillRate = requestsPerSecond;
    this.lastRefill = Date.now();
}

private refill() {
    const now = Date.now();
    const timePassed = (now - this.lastRefill) / 1000;
    const tokensToAdd = timePassed * this.refillRate;
    
    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
    this.lastRefill = now;
}

async acquire(tokens: number = 1): Promise {
    this.refill();
    
    while (this.tokens < tokens) {
        const waitTime = ((tokens - this.tokens) / this.refillRate) * 1000;
        await new Promise(resolve => setTimeout(resolve, waitTime));
        this.refill();
    }
    
    this.tokens -= tokens;
}
}
class BatchContactProcessor {
private rateLimiter: RateLimiter;
private axiosInstance: any;
constructor(axiosInstance: any) {
    this.axiosInstance = axiosInstance;
    this.rateLimiter = new RateLimiter(2); // 2 requests per second
}

async batchCreateContacts(contacts: any[], batchSize: number = 10) {
    const results = [];
    
    for (let i = 0; i < contacts.length; i += batchSize) {
        const batch = contacts.slice(i, i + batchSize);
        
        const batchPromises = batch.map(async (contact) => {
            await this.rateLimiter.acquire();
            
            try {
                const response = await this.axiosInstance.post('/contacts', {
                    locationId: process.env.GOHIGHLEVEL_LOCATION_ID,
                    ...contact
                });
                
                return {
                    success: true,
                    contactId: response.data.contact.id,
                    email: contact.email
                };
            } catch (error) {
                console.error(`Failed to create contact ${contact.email}:`, error);
                return {
                    success: false,
                    email: contact.email,
                    error: error.message
                };
            }
        });
        
        const batchResults = await Promise.all(batchPromises);
        results.push(...batchResults);
        
        console.log(`Processed batch ${Math.floor(i / batchSize) + 1}: ${batchResults.length} contacts`);
    }
    
    return results;
}

async batchUpdateTags(contactIds: string[], tagsToAdd: string[]) {
    const results = [];
    
    for (const contactId of contactIds) {
        await this.rateLimiter.acquire();
        
        try {
            await this.axiosInstance.put(`/contacts/${contactId}`, {
                tags: tagsToAdd
            });
            
            results.push({ success: true, contactId });
        } catch (error) {
            results.push({ success: false, contactId, error: error.message });
        }
    }
    
    return results;
}
}
export { RateLimiter, BatchContactProcessor };

interface ConversationContext {
contactId: string;
conversationId: string;
messages: Array<{
    id: string;
    type: 'SMS' | 'Email' | 'Chat';
    body: string;
    direction: 'inbound' | 'outbound';
    timestamp: string;
}>;
metadata: {
    sentiment: string;
    intent: string;
    keywords: string[];
    urgency: 'low' | 'medium' | 'high';
};
}
class ConversationManager {
private axiosInstance: any;
private contextStore: Map;
constructor(axiosInstance: any) {
    this.axiosInstance = axiosInstance;
    this.contextStore = new Map();
}

async fetchConversationHistory(contactId: string): Promise {
    // Check cache first
    if (this.contextStore.has(contactId)) {
        return this.contextStore.get(contactId)!;
    }

    try {
        const response = await this.axiosInstance.get(`/conversations/search`, {
            params: {
                contactId,
                locationId: process.env.GOHIGHLEVEL_LOCATION_ID
            }
        });

        const conversations = response.data.conversations || [];
        const allMessages = conversations.flatMap(conv => 
            conv.messages.map(msg => ({
                id: msg.id,
                type: msg.type,
                body: msg.body,
                direction: msg.direction,
                timestamp: msg.dateAdded
            }))
        );

        const context: ConversationContext = {
            contactId,
            conversationId: conversations[0]?.id || '',
            messages: allMessages.sort((a, b) => 
                new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
            ),
            metadata: this.analyzeConversation(allMessages)
        };

        this.contextStore.set(contactId, context);
        return context;
    } catch (error) {
        console.error('Error fetching conversation history:', error);
        throw error;
    }
}

private analyzeConversation(messages: any[]): ConversationContext['metadata'] {
    // Simple sentiment and intent analysis
    const text = messages.map(m => m.body).join(' ').toLowerCase();
    
    const urgentKeywords = ['urgent', 'immediately', 'asap', 'emergency', 'critical'];
    const hasUrgentKeyword = urgentKeywords.some(keyword => text.includes(keyword));
    
    const sentiment = this.determineSentiment(text);
    const keywords = this.extractKeywords(text);
    
    return {
        sentiment,
        intent: this.determineIntent(messages),
        keywords,
        urgency: hasUrgentKeyword ? 'high' : 
                messages.length > 5 ? 'medium' : 'low'
    };
}

private determineSentiment(text: string): string {
    const positiveWords = ['great', 'excellent', 'happy', 'satisfied', 'perfect'];
    const negativeWords = ['problem', 'issue', 'frustrated', 'disappointed', 'angry'];
    
    const positiveCount = positiveWords.filter(word => text.includes(word)).length;
    const negativeCount = negativeWords.filter(word => text.includes(word)).length;
    
    if (positiveCount > negativeCount) return 'positive';
    if (negativeCount > positiveCount) return 'negative';
    return 'neutral';
}

private determineIntent(messages: any[]): string {
    const latestMessage = messages[messages.length - 1]?.body.toLowerCase() || '';
    
    if (latestMessage.includes('price') || latestMessage.includes('cost')) {
        return 'pricing_inquiry';
    }
    if (latestMessage.includes('demo') || latestMessage.includes('trial')) {
        return 'demo_request';
    }
    if (latestMessage.includes('help') || latestMessage.includes('support')) {
        return 'support_request';
    }
    
    return 'general_inquiry';
}

private extractKeywords(text: string): string[] {
    const words = text.split(/\s+/);
    const stopWords = ['the', 'is', 'at', 'which', 'on', 'a', 'an', 'and', 'or', 'but'];
    
    return words
        .filter(word => word.length > 4 && !stopWords.includes(word))
        .slice(0, 10);
}

async sendMessage(contactId: string, message: string, type: 'SMS' | 'Email' = 'SMS') {
    try {
        const response = await this.axiosInstance.post(`/conversations/messages`, {
            type,
            contactId,
            message,
            locationId: process.env.GOHIGHLEVEL_LOCATION_ID
        });

        // Update context store
        const context = this.contextStore.get(contactId);
        if (context) {
            context.messages.push({
                id: response.data.messageId,
                type,
                body: message,
                direction: 'outbound',
                timestamp: new Date().toISOString()
            });
        }

        return response.data;
    } catch (error) {
        console.error('Error sending message:', error);
        throw error;
    }
}

getContextSummary(contactId: string): string {
    const context = this.contextStore.get(contactId);
    if (!context) return 'No conversation history available';

    return `
Contact: ${contactId}
Total Messages: ${context.messages.length}
Sentiment: ${context.metadata.sentiment}
Intent: ${context.metadata.intent}
Urgency: ${context.metadata.urgency}
Key Topics: ${context.metadata.keywords.join(', ')}
Last Activity: ${context.messages[context.messages.length - 1]?.timestamp || 'N/A'}
`.trim();
}
}
export default ConversationManager;

import Redis from 'ioredis';
class MCPResourceCache {
private redis: Redis;
private defaultTTL: number = 300; // 5 minutes
constructor(redisUrl: string) {
    this.redis = new Redis(redisUrl);
}

async get(key: string): Promise {
    try {
        const cached = await this.redis.get(key);
        return cached ? JSON.parse(cached) : null;
    } catch (error) {
        console.error('Cache get error:', error);
        return null;
    }
}

async set(key: string, value: any, ttl: number = this.defaultTTL): Promise {
    try {
        await this.redis.setex(key, ttl, JSON.stringify(value));
    } catch (error) {
        console.error('Cache set error:', error);
    }
}

async invalidate(pattern: string): Promise {
    try {
        const keys = await this.redis.keys(pattern);
        if (keys.length > 0) {
            await this.redis.del(...keys);
        }
    } catch (error) {
        console.error('Cache invalidation error:', error);
    }
}

async getOrFetch(
    key: string,
    fetcher: () => Promise,
    ttl?: number
): Promise {
    const cached = await this.get(key);
    if (cached) return cached;

    const fresh = await fetcher();
    await this.set(key, fresh, ttl);
    return fresh;
}
}
// Usage in MCP server
class CachedGHLServer {
private cache: MCPResourceCache;
private axiosInstance: any;
constructor(axiosInstance: any, redisUrl: string) {
    this.axiosInstance = axiosInstance;
    this.cache = new MCPResourceCache(redisUrl);
}

async getContact(contactId: string) {
    return await this.cache.getOrFetch(
        `contact:${contactId}`,
        async () => {
            const response = await this.axiosInstance.get(`/contacts/${contactId}`);
            return response.data;
        },
        600 // Cache for 10 minutes
    );
}

async invalidateContactCache(contactId: string) {
    await this.cache.invalidate(`contact:${contactId}*`);
}
}
export { MCPResourceCache, CachedGHLServer };

import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import { GoHighLevelMCPServer } from './server';
import axios from 'axios';
jest.mock('axios');
const mockedAxios = axios as jest.Mocked;
describe('GoHighLevel MCP Server', () => {
let server: GoHighLevelMCPServer;
let mockAxiosInstance: any;
beforeEach(() => {
    mockAxiosInstance = {
        get: jest.fn(),
        post: jest.fn(),
        put: jest.fn()
    };

    mockedAxios.create.mockReturnValue(mockAxiosInstance);
    server = new GoHighLevelMCPServer();
});

describe('Contact Operations', () => {
    it('should fetch contacts successfully', async () => {
        const mockContacts = [
            { id: '1', email: 'test@example.com', name: 'Test User' },
            { id: '2', email: 'user@example.com', name: 'Another User' }
        ];

        mockAxiosInstance.get.mockResolvedValue({
            data: { contacts: mockContacts }
        });

        const result = await server.fetchContacts();
        
        expect(result).toEqual(mockContacts);
        expect(mockAxiosInstance.get).toHaveBeenCalledWith(
            '/contacts',
            expect.objectContaining({
                params: expect.objectContaining({
                    locationId: process.env.GOHIGHLEVEL_LOCATION_ID
                })
            })
        );
    });

    it('should create contact with proper validation', async () => {
        const newContact = {
            email: 'newuser@example.com',
            name: 'New User',
            phone: '+1234567890'
        };

        mockAxiosInstance.post.mockResolvedValue({
            data: { contact: { id: '123', ...newContact } }
        });

        const result = await server.createContact(newContact);
        
        expect(result.content[0].text).toContain('Contact created successfully');
        expect(mockAxiosInstance.post).toHaveBeenCalledWith(
            '/contacts',
            expect.objectContaining({
                ...newContact,
                locationId: process.env.GOHIGHLEVEL_LOCATION_ID
            })
        );
    });

    it('should handle API errors gracefully', async () => {
        mockAxiosInstance.post.mockRejectedValue(
            new Error('API rate limit exceeded')
        );

        const result = await server.createContact({
            email: 'test@example.com',
            name: 'Test'
        });
        
        expect(result.isError).toBe(true);
        expect(result.content[0].text).toContain('Failed to create contact');
    });
});

describe('Workflow Operations', () => {
    it('should trigger workflow successfully', async () => {
        const args = {
            contactId: 'contact123',
            workflowId: 'workflow456'
        };

        mockAxiosInstance.post.mockResolvedValue({
            data: { success: true }
        });

        const result = await server.triggerWorkflow(args);
        
        expect(result.content[0].text).toContain('Workflow triggered successfully');
    });
});
});

FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY tsconfig.json ./
COPY src ./src
RUN npm run build
FROM node:18-alpine
Create non-root user
RUN addgroup -g 1001 -S nodejs && 
adduser -S nodejs -u 1001
WORKDIR /app
Copy built application
COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
COPY --chown=nodejs:nodejs package.json ./Switch to non-root user
USER nodejsHealth check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 
CMD node -e "require('http').get('http://localhost:3000/health', (r) => {process.exit(r.statusCode === 200 ? 0 : 1)})"EXPOSE 3000CMD ["node", "dist/server.js"]

apiVersion: apps/v1
kind: Deployment
metadata:
name: mcp-gohighlevel-server
labels:
app: mcp-ghl
spec:
replicas: 3
selector:
matchLabels:
app: mcp-ghl
template:
metadata:
labels:
app: mcp-ghl
spec:
containers:
- name: mcp-server
image: your-registry/mcp-gohighlevel:latest
ports:
- containerPort: 3000
env:
- name: GOHIGHLEVEL_API_KEY
valueFrom:
secretKeyRef:
name: ghl-credentials
key: api-key
- name: GOHIGHLEVEL_API_URL
value: "https://rest.gohighlevel.com/v1"
- name: REDIS_URL
valueFrom:
secretKeyRef:
name: redis-credentials
key: url
resources:
requests:
memory: "256Mi"
cpu: "200m"
limits:
memory: "512Mi"
cpu: "500m"
livenessProbe:
httpGet:
path: /health
port: 3000
initialDelaySeconds: 10
periodSeconds: 30
readinessProbe:
httpGet:
path: /ready
port: 3000
initialDelaySeconds: 5
periodSeconds: 10
apiVersion: v1
kind: Service
metadata:
name: mcp-ghl-service
spec:
selector:
app: mcp-ghl
ports:

protocol: TCP
port: 80
targetPort: 3000
type: LoadBalancer


apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: mcp-ghl-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: mcp-gohighlevel-server
minReplicas: 3
maxReplicas: 10
metrics:

type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
type: Resource
resource:
name: memory
target:
type: Utilization
averageUtilization: 80

class CampaignAnalyticsResource {
private axiosInstance: any;
private cache: MCPResourceCache;constructor(axiosInstance: any, cache: MCPResourceCache) {
    this.axiosInstance = axiosInstance;
    this.cache = cache;
}async analyzeCampaignPerformance(campaignId: string, dateRange: { start: string, end: string }) {
    const cacheKey = `analytics:campaign:${campaignId}:${dateRange.start}:${dateRange.end}`;    return await this.cache.getOrFetch(
        cacheKey,
        async () => {
            // Fetch contacts affected by campaign
            const contacts = await this.fetchCampaignContacts(campaignId);            // Calculate engagement metrics
            const engagement = await this.calculateEngagement(contacts, dateRange);            // Fetch conversion data
            const conversions = await this.fetchConversions(contacts, dateRange);            // Calculate revenue attribution
            const revenue = await this.calculateRevenue(conversions);            return {
                campaignId,
                dateRange,
                metrics: {
                    totalContacts: contacts.length,
                    engaged: engagement.engaged,
                    engagementRate: (engagement.engaged / contacts.length) * 100,
                    conversions: conversions.length,
                    conversionRate: (conversions.length / contacts.length) * 100,
                    totalRevenue: revenue.total,
                    averageRevenuePerContact: revenue.total / contacts.length,
                    roi: this.calculateROI(revenue.total, engagement.cost)
                },
                breakdown: {
                    byChannel: engagement.byChannel,
                    byStage: conversions.byStage,
                    timeline: this.generateTimeline(engagement, conversions)
                }
            };
        },
        3600 // Cache for 1 hour
    );
}private async fetchCampaignContacts(campaignId: string): Promise {
    const response = await this.axiosInstance.get('/contacts', {
        params: {
            campaignId,
            locationId: process.env.GOHIGHLEVEL_LOCATION_ID
        }
    });
    return response.data.contacts;
}private async calculateEngagement(contacts: any[], dateRange: any) {
    let engaged = 0;
    const byChannel = { email: 0, sms: 0, call: 0 };    for (const contact of contacts) {
        const activities = await this.fetchContactActivities(contact.id, dateRange);        if (activities.length > 0) {
            engaged++;
            activities.forEach(activity => {
                if (byChannel[activity.type]) {
                    byChannel[activity.type]++;
                }
            });
        }
    }    return {
        engaged,
        byChannel,
        cost: contacts.length * 0.05 // Example cost per contact
    };
}private async fetchContactActivities(contactId: string, dateRange: any) {
    try {
        const response = await this.axiosInstance.get(`/contacts/${contactId}/activities`, {
            params: {
                startDate: dateRange.start,
                endDate: dateRange.end
            }
        });
        return response.data.activities || [];
    } catch (error) {
        return [];
    }
}private async fetchConversions(contacts: any[], dateRange: any) {
    const conversions = [];    for (const contact of contacts) {
        const opportunities = await this.axiosInstance.get('/opportunities', {
            params: {
                contactId: contact.id,
                startDate: dateRange.start,
                endDate: dateRange.end
            }
        });        opportunities.data.opportunities
            ?.filter(opp => opp.status === 'won')
            .forEach(opp => conversions.push({ ...opp, contactId: contact.id }));
    }    return conversions;
}private async calculateRevenue(conversions: any[]) {
    const total = conversions.reduce((sum, conv) => sum + (conv.monetaryValue || 0), 0);
    return { total, conversions: conversions.length };
}private calculateROI(revenue: number, cost: number): number {
    return ((revenue - cost) / cost) * 100;
}private generateTimeline(engagement: any, conversions: any[]) {
    // Generate daily breakdown for visualization
    return {
        daily: [],
        weekly: [],
        summary: 'Timeline data for charting'
    };
}
}export default CampaignAnalyticsResource;