@vantageos/vantage-crm-mcp 0.1.0

package/dist/convex/crm/briefing.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDailyBrief = void 0;
+const server_1 = require("../_generated/server");
+const values_1 = require("convex/values");
+const workspace_1 = require("../lib/workspace");
+// =============================================================================
+// DAILY BRIEFING
+// =============================================================================
+/**
+ * Returns a daily briefing snapshot for the CRM workspace.
+ * Each section includes a count + top 5 items for display.
+ */
+exports.getDailyBrief = (0, server_1.query)({
+    args: {
+        workspaceId: values_1.v.id('workspaces'),
+    },
+    handler: async (ctx, args) => {
+        await (0, workspace_1.validateWorkspaceAccess)(ctx, args.workspaceId);
+        const now = Date.now();
+        const startOfToday = new Date();
+        startOfToday.setHours(0, 0, 0, 0);
+        const todayStart = startOfToday.getTime();
+        const endOfToday = new Date();
+        endOfToday.setHours(23, 59, 59, 999);
+        const todayEnd = endOfToday.getTime();
+        // End of this week (Sunday)
+        const endOfWeek = new Date();
+        endOfWeek.setDate(endOfWeek.getDate() + (7 - endOfWeek.getDay()));
+        endOfWeek.setHours(23, 59, 59, 999);
+        const weekEnd = endOfWeek.getTime();
+        // 7 days ago for stale contacts
+        const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
+        // -----------------------------------------------------------------------
+        // 1. Deals closing this week
+        // -----------------------------------------------------------------------
+        const allDeals = await ctx.db
+            .query('deals')
+            .withIndex('by_workspace', (q) => q.eq('workspaceId', args.workspaceId))
+            .take(1000);
+        const activeDeals = allDeals.filter((d) => d.isArchived !== true &&
+            !d.stage.toLowerCase().includes('lost') &&
+            !d.stage.toLowerCase().includes('closed'));
+        const dealsClosingThisWeek = activeDeals
+            .filter((d) => d.expectedCloseDate !== undefined &&
+            d.expectedCloseDate >= todayStart &&
+            d.expectedCloseDate <= weekEnd)
+            .sort((a, b) => (a.expectedCloseDate ?? 0) - (b.expectedCloseDate ?? 0));
+        // Enrich with contact/company names
+        const enrichedDeals = await Promise.all(dealsClosingThisWeek.slice(0, 5).map(async (deal) => {
+            let contactName;
+            let companyName;
+            if (deal.contactId) {
+                const contact = await ctx.db.get(deal.contactId);
+                if (contact)
+                    contactName = `${contact.firstName} ${contact.lastName}`;
+            }
+            if (deal.companyId) {
+                const company = await ctx.db.get(deal.companyId);
+                if (company)
+                    companyName = company.name;
+            }
+            return {
+                _id: deal._id,
+                title: deal.title,
+                stage: deal.stage,
+                value: deal.value,
+                currency: deal.currency,
+                expectedCloseDate: deal.expectedCloseDate,
+                probability: deal.probability,
+                contactName,
+                companyName,
+            };
+        }));
+        // -----------------------------------------------------------------------
+        // 2. Overdue tasks
+        // -----------------------------------------------------------------------
+        const allTasks = await ctx.db
+            .query('activities')
+            .withIndex('by_workspace_type', (q) => q.eq('workspaceId', args.workspaceId).eq('type', 'task'))
+            .take(1000);
+        const overdueTasks = allTasks
+            .filter((t) => t.completedAt === undefined &&
+            t.dueAt !== undefined &&
+            t.dueAt < now)
+            .sort((a, b) => (a.dueAt ?? 0) - (b.dueAt ?? 0));
+        const enrichedOverdueTasks = await Promise.all(overdueTasks.slice(0, 5).map(async (task) => {
+            let contactName;
+            let dealTitle;
+            if (task.contactId) {
+                const contact = await ctx.db.get(task.contactId);
+                if (contact)
+                    contactName = `${contact.firstName} ${contact.lastName}`;
+            }
+            if (task.dealId) {
+                const deal = await ctx.db.get(task.dealId);
+                if (deal)
+                    dealTitle = deal.title;
+            }
+            return {
+                _id: task._id,
+                subject: task.subject,
+                dueAt: task.dueAt,
+                contactName,
+                dealTitle,
+            };
+        }));
+        // -----------------------------------------------------------------------
+        // 3. Stale contacts (not contacted in 7+ days)
+        // -----------------------------------------------------------------------
+        const allContacts = await ctx.db
+            .query('contacts')
+            .withIndex('by_workspace', (q) => q.eq('workspaceId', args.workspaceId))
+            .take(1000);
+        const staleContacts = allContacts
+            .filter((c) => c.isArchived !== true &&
+            (c.type === 'lead' || c.type === 'prospect') &&
+            (c.lastContactedAt === undefined || c.lastContactedAt < sevenDaysAgo))
+            .sort((a, b) => (a.lastContactedAt ?? 0) - (b.lastContactedAt ?? 0));
+        const enrichedStaleContacts = await Promise.all(staleContacts.slice(0, 5).map(async (contact) => {
+            let companyName;
+            if (contact.companyId) {
+                const company = await ctx.db.get(contact.companyId);
+                if (company)
+                    companyName = company.name;
+            }
+            return {
+                _id: contact._id,
+                firstName: contact.firstName,
+                lastName: contact.lastName,
+                email: contact.email,
+                type: contact.type,
+                lastContactedAt: contact.lastContactedAt,
+                companyName,
+            };
+        }));
+        // -----------------------------------------------------------------------
+        // 4. Today's meetings (from calendarEvents)
+        // -----------------------------------------------------------------------
+        const calendarEvents = await ctx.db
+            .query('calendarEvents')
+            .withIndex('by_workspace_start', (q) => q
+            .eq('workspaceId', args.workspaceId)
+            .gte('startTime', todayStart)
+            .lte('startTime', todayEnd))
+            .take(50);
+        const todaysMeetings = calendarEvents
+            .sort((a, b) => a.startTime - b.startTime)
+            .slice(0, 5)
+            .map((event) => ({
+            _id: event._id,
+            title: event.title,
+            startTime: event.startTime,
+            endTime: event.endTime,
+            description: event.description,
+            attendeeCount: event.attendees?.length ?? 0,
+        }));
+        // -----------------------------------------------------------------------
+        // 5. Pipeline stats
+        // -----------------------------------------------------------------------
+        const stageMap = new Map();
+        for (const deal of activeDeals) {
+            const existing = stageMap.get(deal.stage) ?? { count: 0, totalValue: 0 };
+            existing.count += 1;
+            existing.totalValue += deal.value ?? 0;
+            stageMap.set(deal.stage, existing);
+        }
+        const pipelineStats = {
+            totalDeals: activeDeals.length,
+            totalValue: activeDeals.reduce((sum, d) => sum + (d.value ?? 0), 0),
+            weightedValue: activeDeals.reduce((sum, d) => sum + ((d.value ?? 0) * (d.probability ?? 0)) / 100, 0),
+            byStage: Array.from(stageMap.entries()).map(([stage, data]) => ({
+                stage,
+                count: data.count,
+                totalValue: data.totalValue,
+            })),
+        };
+        return {
+            dealsClosingThisWeek: {
+                count: dealsClosingThisWeek.length,
+                items: enrichedDeals,
+            },
+            overdueTasks: {
+                count: overdueTasks.length,
+                items: enrichedOverdueTasks,
+            },
+            staleContacts: {
+                count: staleContacts.length,
+                items: enrichedStaleContacts,
+            },
+            todaysMeetings: {
+                count: calendarEvents.length,
+                items: todaysMeetings,
+            },
+            pipelineStats,
+        };
+    },
+});

package/dist/convex/crm/calendarCron.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Calendar Cron — Action that syncs Google Calendar events via Composio.
+ *
+ * Runs every 5 minutes via Convex cron scheduler.
+ * Flow: fetch events from Composio → transform → upsert via calendarSync.syncEvents
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triggerSync = exports.syncCalendarEvents = void 0;
+const server_1 = require("../_generated/server");
+const api_1 = require("../_generated/api");
+const values_1 = require("convex/values");
+// =============================================================================
+// SYNC CALENDAR EVENTS — internal action called by cron
+// =============================================================================
+exports.syncCalendarEvents = (0, server_1.internalAction)({
+    args: {
+        workspaceId: values_1.v.id('workspaces'),
+        entityId: values_1.v.string(),
+    },
+    handler: async (ctx, args) => {
+        console.log('[CalendarCron] Starting sync for workspace:', args.workspaceId, 'entity:', args.entityId);
+        try {
+            // Call the Next.js API route that wraps Composio
+            // Convex actions can't import Node.js-only Composio SDK directly,
+            // so we call the integration endpoint via fetch.
+            const appUrl = process.env.NEXT_PUBLIC_APP_URL;
+            if (!appUrl) {
+                console.error('[CalendarCron] NEXT_PUBLIC_APP_URL not configured');
+                return { success: false, error: 'App URL not configured' };
+            }
+            const cronSecret = process.env.CRON_SECRET;
+            if (!cronSecret) {
+                console.error('[CalendarCron] CRON_SECRET not configured');
+                return { success: false, error: 'Cron secret not configured' };
+            }
+            // Fetch events from the calendar sync API endpoint
+            const response = await fetch(`${appUrl}/api/integrations/calendar-sync`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${cronSecret}`,
+                },
+                body: JSON.stringify({
+                    entityId: args.entityId,
+                    workspaceId: args.workspaceId,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                console.error('[CalendarCron] API call failed:', response.status, errorText);
+                return { success: false, error: `API error: ${response.status}` };
+            }
+            const data = (await response.json());
+            if (!data.events || data.events.length === 0) {
+                console.log('[CalendarCron] No events to sync');
+                return { success: true, upserted: 0, linked: 0 };
+            }
+            console.log('[CalendarCron] Fetched', data.events.length, 'events from Composio');
+            // Upsert events into Convex via internal mutation
+            const result = await ctx.runMutation(api_1.internal.crm.calendarSync.syncEvents, {
+                workspaceId: args.workspaceId,
+                events: data.events,
+            });
+            console.log('[CalendarCron] Sync complete:', result.upserted, 'upserted,', result.linked, 'linked');
+            return { success: true, upserted: result.upserted, linked: result.linked };
+        }
+        catch (error) {
+            console.error('[CalendarCron] Sync failed:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+// =============================================================================
+// TRIGGER SYNC — internal action to manually trigger calendar sync
+// =============================================================================
+exports.triggerSync = (0, server_1.internalAction)({
+    args: {
+        workspaceId: values_1.v.id('workspaces'),
+        entityId: values_1.v.string(),
+    },
+    handler: async (ctx, args) => {
+        const result = await ctx.runAction(api_1.internal.crm.calendarCron.syncCalendarEvents, {
+            workspaceId: args.workspaceId,
+            entityId: args.entityId,
+        });
+        return result;
+    },
+});

package/dist/convex/crm/calendarCronDispatch.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Calendar Cron Dispatcher
+ *
+ * Finds all workspaces with Google Calendar sync enabled
+ * and triggers sync for each one.
+ *
+ * The cron calls this dispatcher every 5 minutes.
+ * The dispatcher then fans out to per-workspace sync actions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCalendarSyncWorkspaces = exports.dispatchCalendarSync = void 0;
+const server_1 = require("../_generated/server");
+const api_1 = require("../_generated/api");
+// =============================================================================
+// DISPATCH — find workspaces and fan out sync actions
+// =============================================================================
+exports.dispatchCalendarSync = (0, server_1.internalAction)({
+    args: {},
+    handler: async (ctx) => {
+        console.log('[CalendarCronDispatch] Starting dispatch...');
+        // Get all workspaces that have calendar sync configured
+        const workspaces = await ctx.runQuery(api_1.internal.crm.calendarCronDispatch.getCalendarSyncWorkspaces);
+        if (workspaces.length === 0) {
+            console.log('[CalendarCronDispatch] No workspaces with calendar sync enabled');
+            return { dispatched: 0 };
+        }
+        console.log('[CalendarCronDispatch] Dispatching sync for', workspaces.length, 'workspaces');
+        // Fan out sync actions for each workspace
+        let dispatched = 0;
+        for (const ws of workspaces) {
+            try {
+                await ctx.runAction(api_1.internal.crm.calendarCron.syncCalendarEvents, {
+                    workspaceId: ws.workspaceId,
+                    entityId: ws.entityId,
+                });
+                dispatched++;
+            }
+            catch (error) {
+                console.error('[CalendarCronDispatch] Failed for workspace:', ws.workspaceId, error);
+            }
+        }
+        console.log('[CalendarCronDispatch] Dispatched', dispatched, 'sync jobs');
+        return { dispatched };
+    },
+});
+// =============================================================================
+// QUERY — get workspaces with calendar sync enabled
+// =============================================================================
+exports.getCalendarSyncWorkspaces = (0, server_1.internalQuery)({
+    args: {},
+    handler: async (ctx) => {
+        // Get all workspaces and filter to those with calendarSyncEnabled setting
+        const workspaces = await ctx.db.query('workspaces').collect();
+        const results = [];
+        for (const ws of workspaces) {
+            // Only sync workspaces that have calendar sync enabled
+            if (!ws.settings?.calendarSyncEnabled)
+                continue;
+            // Determine entityId: for personal workspaces use the owner's clerkId,
+            // for org workspaces use the orgId
+            let entityId;
+            if (ws.ownerType === 'user' && ws.ownerId) {
+                // Get the user's clerkId from the users table
+                const user = await ctx.db.get(ws.ownerId);
+                if (user) {
+                    entityId = user.clerkId;
+                }
+            }
+            else if (ws.ownerType === 'organization' && ws.orgId) {
+                // For org workspaces, get the Clerk orgId from organizations table
+                const org = await ctx.db.get(ws.orgId);
+                if (org) {
+                    entityId = org.clerkId;
+                }
+            }
+            if (entityId) {
+                results.push({ workspaceId: ws._id, entityId });
+            }
+        }
+        return results;
+    },
+});

package/dist/convex/crm/calendarSync.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * Calendar Sync — Mutations for upserting Google Calendar events
+ * and auto-linking attendees to contacts/companies.
+ *
+ * Sync flow: cron → Composio API → this module upserts into calendarEvents table.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMeetingBrief = exports.listByContact = exports.listUpcoming = exports.linkToContact = exports.syncEvents = void 0;
+const server_1 = require("../_generated/server");
+const values_1 = require("convex/values");
+// =============================================================================
+// VALIDATORS
+// =============================================================================
+const attendeeValidator = values_1.v.object({
+    email: values_1.v.string(),
+    name: values_1.v.optional(values_1.v.string()),
+    status: values_1.v.optional(values_1.v.string()),
+});
+const calendarEventValidator = {
+    googleEventId: values_1.v.string(),
+    calendarId: values_1.v.string(),
+    title: values_1.v.string(),
+    description: values_1.v.optional(values_1.v.string()),
+    location: values_1.v.optional(values_1.v.string()),
+    startTime: values_1.v.number(),
+    endTime: values_1.v.number(),
+    isAllDay: values_1.v.optional(values_1.v.boolean()),
+    attendees: values_1.v.optional(values_1.v.array(attendeeValidator)),
+};
+// =============================================================================
+// SYNC EVENTS — upsert by googleEventId (internal, called by cron action)
+// =============================================================================
+exports.syncEvents = (0, server_1.internalMutation)({
+    args: {
+        workspaceId: values_1.v.id('workspaces'),
+        events: values_1.v.array(values_1.v.object(calendarEventValidator)),
+    },
+    handler: async (ctx, args) => {
+        const now = Date.now();
+        const results = {
+            upserted: 0,
+            linked: 0,
+        };
+        for (const event of args.events) {
+            // Check if event already exists by googleEventId
+            const existing = await ctx.db
+                .query('calendarEvents')
+                .withIndex('by_google_event', (q) => q.eq('googleEventId', event.googleEventId))
+                .first();
+            // Auto-link: match attendee emails to contacts and companies
+            let contactId;
+            let companyId;
+            if (event.attendees && event.attendees.length > 0) {
+                for (const attendee of event.attendees) {
+                    if (!attendee.email)
+                        continue;
+                    // Match contact by email
+                    if (!contactId) {
+                        const contact = await ctx.db
+                            .query('contacts')
+                            .withIndex('by_workspace', (q) => q.eq('workspaceId', args.workspaceId))
+                            .filter((q) => q.eq(q.field('email'), attendee.email))
+                            .first();
+                        if (contact) {
+                            contactId = contact._id;
+                            // If contact has a company, use that too
+                            if (contact.companyId) {
+                                companyId = contact.companyId;
+                            }
+                        }
+                    }
+                    // Match company by domain (extract domain from email)
+                    if (!companyId) {
+                        const emailDomain = attendee.email.split('@')[1]?.toLowerCase();
+                        if (emailDomain &&
+                            !['gmail.com', 'yahoo.com', 'hotmail.com', 'outlook.com', 'icloud.com', 'protonmail.com'].includes(emailDomain)) {
+                            const company = await ctx.db
+                                .query('companies')
+                                .withIndex('by_workspace', (q) => q.eq('workspaceId', args.workspaceId))
+                                .filter((q) => q.eq(q.field('domain'), emailDomain))
+                                .first();
+                            if (company) {
+                                companyId = company._id;
+                            }
+                        }
+                    }
+                    // Stop early if both found
+                    if (contactId && companyId)
+                        break;
+                }
+                if (contactId || companyId)
+                    results.linked++;
+            }
+            if (existing) {
+                // Update existing event
+                await ctx.db.patch(existing._id, {
+                    title: event.title,
+                    description: event.description,
+                    startTime: event.startTime,
+                    endTime: event.endTime,
+                    attendees: event.attendees,
+                    contactId,
+                    companyId,
+                    syncedAt: now,
+                });
+            }
+            else {
+                // Insert new event
+                await ctx.db.insert('calendarEvents', {
+                    googleEventId: event.googleEventId,
+                    title: event.title,
+                    description: event.description,
+                    startTime: event.startTime,
+                    endTime: event.endTime,
+                    attendees: event.attendees,
+                    contactId,
+                    companyId,
+                    workspaceId: args.workspaceId,
+                    syncedAt: now,
+                });
+                // Auto-create meeting activity if linked to a contact
+                if (contactId) {
+                    await ctx.db.insert('activities', {
+                        type: 'calendar-event',
+                        subject: event.title,
+                        description: event.description,
+                        contactId,
+                        companyId,
+                        workspaceId: args.workspaceId,
+                        ownerId: 'system',
+                        actorType: 'agent',
+                        actorId: 'agent:composio',
+                        occurredAt: event.startTime,
+                        createdAt: now,
+                        updatedAt: now,
+                    });
+                    // Update lastContactedAt on contact
+                    await ctx.db.patch(contactId, {
+                        lastContactedAt: event.startTime,
+                        updatedAt: now,
+                    });
+                }
+            }
+            results.upserted++;
+        }
+        return results;
+    },
+});
+// =============================================================================
+// LINK TO CONTACT — manually link a calendar event to a contact
+// =============================================================================
+exports.linkToContact = (0, server_1.mutation)({
+    args: {
+        eventId: values_1.v.id('calendarEvents'),
+        contactId: values_1.v.optional(values_1.v.id('contacts')),
+        companyId: values_1.v.optional(values_1.v.id('companies')),
+        dealId: values_1.v.optional(values_1.v.id('deals')),
+    },
+    handler: async (ctx, args) => {
+        const event = await ctx.db.get(args.eventId);
+        if (!event)
+            throw new Error('Calendar event not found');
+        const now = Date.now();
+        await ctx.db.patch(args.eventId, {
+            contactId: args.contactId,
+            companyId: args.companyId,
+            dealId: args.dealId,
+        });
+        return { success: true };
+    },
+});
+// =============================================================================
+// QUERIES
+// =============================================================================
+/** List upcoming events for a workspace */
+exports.listUpcoming = (0, server_1.query)({
+    args: {
+        workspaceId: values_1.v.id('workspaces'),
+        fromTime: values_1.v.optional(values_1.v.number()),
+        toTime: values_1.v.optional(values_1.v.number()),
+        limit: values_1.v.optional(values_1.v.number()),
+    },
+    handler: async (ctx, args) => {
+        const from = args.fromTime ?? Date.now();
+        const to = args.toTime ?? from + 7 * 24 * 60 * 60 * 1000; // default 7 days ahead
+        const events = await ctx.db
+            .query('calendarEvents')
+            .withIndex('by_workspace_start', (q) => q
+            .eq('workspaceId', args.workspaceId)
+            .gte('startTime', from)
+            .lte('startTime', to))
+            .order('asc')
+            .take(args.limit ?? 50);
+        return events;
+    },
+});
+/** List events linked to a specific contact */
+exports.listByContact = (0, server_1.query)({
+    args: {
+        contactId: values_1.v.id('contacts'),
+        limit: values_1.v.optional(values_1.v.number()),
+    },
+    handler: async (ctx, args) => {
+        return await ctx.db
+            .query('calendarEvents')
+            .withIndex('by_contact', (q) => q.eq('contactId', args.contactId))
+            .order('desc')
+            .take(args.limit ?? 20);
+    },
+});
+/** Get pre-meeting brief: contact + deal context for next meeting */
+exports.getMeetingBrief = (0, server_1.query)({
+    args: {
+        eventId: values_1.v.id('calendarEvents'),
+    },
+    handler: async (ctx, args) => {
+        const event = await ctx.db.get(args.eventId);
+        if (!event)
+            return null;
+        let contact = null;
+        let company = null;
+        let deal = null;
+        const recentActivities = [];
+        if (event.contactId) {
+            contact = await ctx.db.get(event.contactId);
+            // Get recent activities for this contact
+            const activities = await ctx.db
+                .query('activities')
+                .withIndex('by_contact', (q) => q.eq('contactId', event.contactId))
+                .order('desc')
+                .take(10);
+            recentActivities.push(...activities.map((a) => ({
+                type: a.type,
+                subject: a.subject,
+                occurredAt: a.occurredAt,
+            })));
+        }
+        if (event.companyId) {
+            company = await ctx.db.get(event.companyId);
+        }
+        if (event.dealId) {
+            deal = await ctx.db.get(event.dealId);
+        }
+        else if (event.contactId) {
+            // Try to find an active deal for this contact
+            deal = await ctx.db
+                .query('deals')
+                .withIndex('by_contact', (q) => q.eq('contactId', event.contactId))
+                .filter((q) => q.neq(q.field('isArchived'), true))
+                .first();
+        }
+        return {
+            event: {
+                title: event.title,
+                startTime: event.startTime,
+                endTime: event.endTime,
+                description: event.description,
+                attendees: event.attendees,
+            },
+            contact: contact
+                ? {
+                    id: contact._id,
+                    name: `${contact.firstName} ${contact.lastName}`,
+                    email: contact.email,
+                    phone: contact.phone,
+                    type: contact.type,
+                    jobTitle: contact.jobTitle,
+                    notes: contact.notes,
+                    lastContactedAt: contact.lastContactedAt,
+                }
+                : null,
+            company: company
+                ? {
+                    id: company._id,
+                    name: company.name,
+                    domain: company.domain,
+                    industry: company.industry,
+                    size: company.size,
+                }
+                : null,
+            deal: deal
+                ? {
+                    id: deal._id,
+                    title: deal.title,
+                    stage: deal.stage,
+                    value: deal.value,
+                    probability: deal.probability,
+                }
+                : null,
+            recentActivities,
+        };
+    },
+});