@vantageos/vantage-crm-mcp 0.1.0

package/dist/convex/workspaces.js

@@ -0,0 +1,603 @@
+"use strict";
+/**
+ * Workspace management functions
+ *
+ * Workspaces are the primary container for all user/team data:
+ * - Personal workspaces: owned by a user (1 default + unlimited additional)
+ * - Organization workspaces: owned by an org, shared by team members
+ *
+ * Each workspace has its own chats, flows, integrations, and settings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContext = exports.remove = exports.removeMember = exports.addMember = exports.update = exports.switchTo = exports.ensureDefaultWorkspace = exports.createForOrg = exports.createPersonal = exports.getMembers = exports.getCurrent = exports.getById = exports.list = void 0;
+const values_1 = require("convex/values");
+const server_1 = require("./_generated/server");
+// ============================================================================
+// QUERIES
+// ============================================================================
+/**
+ * Get all workspaces the current user has access to
+ */
+exports.list = (0, server_1.query)({
+    args: {},
+    handler: async (ctx) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            return [];
+        // Find user
+        const user = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!user)
+            return [];
+        // Get personal workspaces (owned by user)
+        const personalWorkspaces = await ctx.db
+            .query('workspaces')
+            .withIndex('by_owner', (q) => q.eq('ownerId', user._id))
+            .filter((q) => q.eq(q.field('ownerType'), 'user'))
+            .collect();
+        // Get org workspaces user is a member of
+        const workspaceMemberships = await ctx.db
+            .query('workspaceMembers')
+            .withIndex('by_user', (q) => q.eq('userId', user._id))
+            .collect();
+        const orgWorkspaces = await Promise.all(workspaceMemberships.map(async (membership) => {
+            const workspace = await ctx.db.get(membership.workspaceId);
+            if (!workspace)
+                return null;
+            return {
+                ...workspace,
+                memberRole: membership.role,
+                memberPermissions: membership.permissions,
+            };
+        }));
+        // Combine and sort
+        const allWorkspaces = [
+            ...personalWorkspaces.map((ws) => ({
+                ...ws,
+                memberRole: 'owner',
+                memberPermissions: null,
+            })),
+            ...orgWorkspaces.filter(Boolean),
+        ].sort((a, b) => {
+            // Default workspace first
+            if (a?.isDefault)
+                return -1;
+            if (b?.isDefault)
+                return 1;
+            // Then by last accessed
+            return (b?.lastAccessedAt || 0) - (a?.lastAccessedAt || 0);
+        });
+        return allWorkspaces;
+    },
+});
+/**
+ * Get a specific workspace by ID
+ */
+exports.getById = (0, server_1.query)({
+    args: { workspaceId: values_1.v.id('workspaces') },
+    handler: async (ctx, { workspaceId }) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            return null;
+        const workspace = await ctx.db.get(workspaceId);
+        if (!workspace)
+            return null;
+        // Check access
+        const user = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!user)
+            return null;
+        // Owner always has access
+        if (workspace.ownerId === user._id) {
+            return { ...workspace, memberRole: 'owner', canEdit: true };
+        }
+        // Check workspace membership
+        const membership = await ctx.db
+            .query('workspaceMembers')
+            .withIndex('by_workspace_user', (q) => q.eq('workspaceId', workspaceId).eq('userId', user._id))
+            .first();
+        if (membership) {
+            const canEdit = ['owner', 'admin', 'editor'].includes(membership.role);
+            return { ...workspace, memberRole: membership.role, canEdit };
+        }
+        return null; // No access
+    },
+});
+/**
+ * Get the current/active workspace for the user
+ */
+exports.getCurrent = (0, server_1.query)({
+    args: {},
+    handler: async (ctx) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            return null;
+        const user = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!user)
+            return null;
+        // If user has an active workspace, return it
+        if (user.activeWorkspaceId) {
+            const workspace = await ctx.db.get(user.activeWorkspaceId);
+            if (workspace)
+                return workspace;
+        }
+        // Otherwise, return their default personal workspace
+        const defaultWorkspace = await ctx.db
+            .query('workspaces')
+            .withIndex('by_owner', (q) => q.eq('ownerId', user._id))
+            .filter((q) => q.and(q.eq(q.field('ownerType'), 'user'), q.eq(q.field('isDefault'), true)))
+            .first();
+        return defaultWorkspace;
+    },
+});
+/**
+ * Get workspace members
+ */
+exports.getMembers = (0, server_1.query)({
+    args: { workspaceId: values_1.v.id('workspaces') },
+    handler: async (ctx, { workspaceId }) => {
+        const memberships = await ctx.db
+            .query('workspaceMembers')
+            .withIndex('by_workspace', (q) => q.eq('workspaceId', workspaceId))
+            .collect();
+        const members = await Promise.all(memberships.map(async (membership) => {
+            const user = await ctx.db.get(membership.userId);
+            return {
+                ...membership,
+                user: user
+                    ? {
+                        _id: user._id,
+                        name: user.name,
+                        email: user.email,
+                        avatarUrl: user.avatarUrl,
+                    }
+                    : null,
+            };
+        }));
+        return members;
+    },
+});
+// ============================================================================
+// MUTATIONS
+// ============================================================================
+/**
+ * Create a new personal workspace
+ */
+exports.createPersonal = (0, server_1.mutation)({
+    args: {
+        name: values_1.v.string(),
+        slug: values_1.v.optional(values_1.v.string()),
+        description: values_1.v.optional(values_1.v.string()),
+        icon: values_1.v.optional(values_1.v.string()),
+        color: values_1.v.optional(values_1.v.string()),
+    },
+    handler: async (ctx, args) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            throw new Error('Not authenticated');
+        const user = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!user)
+            throw new Error('User not found');
+        // Check if this is the first workspace (make it default)
+        const existingWorkspaces = await ctx.db
+            .query('workspaces')
+            .withIndex('by_owner', (q) => q.eq('ownerId', user._id))
+            .filter((q) => q.eq(q.field('ownerType'), 'user'))
+            .collect();
+        const isDefault = existingWorkspaces.length === 0;
+        const workspaceId = await ctx.db.insert('workspaces', {
+            name: args.name,
+            slug: args.slug,
+            description: args.description,
+            icon: args.icon,
+            color: args.color,
+            ownerType: 'user',
+            ownerId: user._id,
+            isDefault,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        });
+        // Set as active if it's the first one
+        if (isDefault) {
+            await ctx.db.patch(user._id, { activeWorkspaceId: workspaceId });
+        }
+        return workspaceId;
+    },
+});
+/**
+ * Create a new organization workspace
+ */
+exports.createForOrg = (0, server_1.mutation)({
+    args: {
+        orgId: values_1.v.id('organizations'),
+        name: values_1.v.string(),
+        slug: values_1.v.optional(values_1.v.string()),
+        description: values_1.v.optional(values_1.v.string()),
+        icon: values_1.v.optional(values_1.v.string()),
+        color: values_1.v.optional(values_1.v.string()),
+    },
+    handler: async (ctx, args) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            throw new Error('Not authenticated');
+        const user = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!user)
+            throw new Error('User not found');
+        // Check user is admin of the org
+        const membership = await ctx.db
+            .query('memberships')
+            .withIndex('by_user_org', (q) => q.eq('userId', user._id).eq('orgId', args.orgId))
+            .first();
+        const canCreate = membership?.role === 'org:admin' ||
+            membership?.permissions?.canCreateWorkspaces;
+        if (!canCreate) {
+            throw new Error('You need admin access to create organization workspaces');
+        }
+        const workspaceId = await ctx.db.insert('workspaces', {
+            name: args.name,
+            slug: args.slug,
+            description: args.description,
+            icon: args.icon,
+            color: args.color,
+            ownerType: 'organization',
+            ownerId: user._id, // Creator
+            orgId: args.orgId,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        });
+        // Add creator as workspace owner
+        await ctx.db.insert('workspaceMembers', {
+            workspaceId,
+            userId: user._id,
+            role: 'owner',
+            addedAt: Date.now(),
+        });
+        // Update org workspace count
+        const org = await ctx.db.get(args.orgId);
+        if (org) {
+            await ctx.db.patch(args.orgId, {
+                workspaceCount: (org.workspaceCount || 0) + 1,
+                updatedAt: Date.now(),
+            });
+        }
+        return workspaceId;
+    },
+});
+/**
+ * Ensure user has a default personal workspace
+ * Called during user sync
+ */
+exports.ensureDefaultWorkspace = (0, server_1.mutation)({
+    args: { userId: values_1.v.id('users') },
+    handler: async (ctx, { userId }) => {
+        const user = await ctx.db.get(userId);
+        if (!user)
+            throw new Error('User not found');
+        // Check if default workspace exists
+        const defaultWorkspace = await ctx.db
+            .query('workspaces')
+            .withIndex('by_owner', (q) => q.eq('ownerId', userId))
+            .filter((q) => q.and(q.eq(q.field('ownerType'), 'user'), q.eq(q.field('isDefault'), true)))
+            .first();
+        if (defaultWorkspace) {
+            return defaultWorkspace._id;
+        }
+        // Create default personal workspace
+        const workspaceId = await ctx.db.insert('workspaces', {
+            name: 'Personal',
+            ownerType: 'user',
+            ownerId: userId,
+            isDefault: true,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        });
+        // Set as active workspace
+        await ctx.db.patch(userId, { activeWorkspaceId: workspaceId });
+        return workspaceId;
+    },
+});
+/**
+ * Switch to a different workspace
+ */
+exports.switchTo = (0, server_1.mutation)({
+    args: { workspaceId: values_1.v.id('workspaces') },
+    handler: async (ctx, { workspaceId }) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            throw new Error('Not authenticated');
+        const user = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!user)
+            throw new Error('User not found');
+        // Verify access to workspace
+        const workspace = await ctx.db.get(workspaceId);
+        if (!workspace)
+            throw new Error('Workspace not found');
+        // Check ownership or membership
+        const hasAccess = workspace.ownerId === user._id ||
+            (await ctx.db
+                .query('workspaceMembers')
+                .withIndex('by_workspace_user', (q) => q.eq('workspaceId', workspaceId).eq('userId', user._id))
+                .first());
+        if (!hasAccess)
+            throw new Error('No access to this workspace');
+        // Update user's active workspace
+        await ctx.db.patch(user._id, { activeWorkspaceId: workspaceId });
+        // Update workspace last accessed
+        await ctx.db.patch(workspaceId, { lastAccessedAt: Date.now() });
+        return { success: true };
+    },
+});
+/**
+ * Update workspace details
+ */
+exports.update = (0, server_1.mutation)({
+    args: {
+        workspaceId: values_1.v.id('workspaces'),
+        name: values_1.v.optional(values_1.v.string()),
+        slug: values_1.v.optional(values_1.v.string()),
+        description: values_1.v.optional(values_1.v.string()),
+        icon: values_1.v.optional(values_1.v.string()),
+        color: values_1.v.optional(values_1.v.string()),
+        settings: values_1.v.optional(values_1.v.object({
+            defaultModel: values_1.v.optional(values_1.v.string()),
+            theme: values_1.v.optional(values_1.v.string()),
+            enabledTools: values_1.v.optional(values_1.v.array(values_1.v.string())),
+        })),
+    },
+    handler: async (ctx, { workspaceId, ...updates }) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            throw new Error('Not authenticated');
+        const user = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!user)
+            throw new Error('User not found');
+        const workspace = await ctx.db.get(workspaceId);
+        if (!workspace)
+            throw new Error('Workspace not found');
+        // Check edit permission
+        let canEdit = workspace.ownerId === user._id;
+        if (!canEdit) {
+            const membership = await ctx.db
+                .query('workspaceMembers')
+                .withIndex('by_workspace_user', (q) => q.eq('workspaceId', workspaceId).eq('userId', user._id))
+                .first();
+            canEdit = ['owner', 'admin'].includes(membership?.role || '');
+        }
+        if (!canEdit)
+            throw new Error('No permission to edit this workspace');
+        // Build update object
+        const patchData = { updatedAt: Date.now() };
+        if (updates.name !== undefined)
+            patchData.name = updates.name;
+        if (updates.slug !== undefined)
+            patchData.slug = updates.slug;
+        if (updates.description !== undefined)
+            patchData.description = updates.description;
+        if (updates.icon !== undefined)
+            patchData.icon = updates.icon;
+        if (updates.color !== undefined)
+            patchData.color = updates.color;
+        if (updates.settings !== undefined) {
+            patchData.settings = { ...workspace.settings, ...updates.settings };
+        }
+        await ctx.db.patch(workspaceId, patchData);
+        return { success: true };
+    },
+});
+/**
+ * Add a member to an org workspace
+ */
+exports.addMember = (0, server_1.mutation)({
+    args: {
+        workspaceId: values_1.v.id('workspaces'),
+        userId: values_1.v.id('users'),
+        role: values_1.v.union(values_1.v.literal('admin'), values_1.v.literal('editor'), values_1.v.literal('viewer')),
+    },
+    handler: async (ctx, { workspaceId, userId, role }) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            throw new Error('Not authenticated');
+        const currentUser = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!currentUser)
+            throw new Error('User not found');
+        const workspace = await ctx.db.get(workspaceId);
+        if (!workspace)
+            throw new Error('Workspace not found');
+        // Only org workspaces can have members added
+        if (workspace.ownerType !== 'organization') {
+            throw new Error('Can only add members to organization workspaces');
+        }
+        // Check permission
+        let canInvite = workspace.ownerId === currentUser._id;
+        if (!canInvite) {
+            const membership = await ctx.db
+                .query('workspaceMembers')
+                .withIndex('by_workspace_user', (q) => q.eq('workspaceId', workspaceId).eq('userId', currentUser._id))
+                .first();
+            canInvite =
+                ['owner', 'admin'].includes(membership?.role || '') ||
+                    membership?.permissions?.canInviteMembers === true;
+        }
+        if (!canInvite)
+            throw new Error('No permission to add members');
+        // Check if already a member
+        const existingMembership = await ctx.db
+            .query('workspaceMembers')
+            .withIndex('by_workspace_user', (q) => q.eq('workspaceId', workspaceId).eq('userId', userId))
+            .first();
+        if (existingMembership) {
+            throw new Error('User is already a member of this workspace');
+        }
+        // Add member
+        await ctx.db.insert('workspaceMembers', {
+            workspaceId,
+            userId,
+            role,
+            addedAt: Date.now(),
+            addedBy: currentUser._id,
+        });
+        // Update member count
+        await ctx.db.patch(workspaceId, {
+            memberCount: (workspace.memberCount || 0) + 1,
+            updatedAt: Date.now(),
+        });
+        return { success: true };
+    },
+});
+/**
+ * Remove a member from workspace
+ */
+exports.removeMember = (0, server_1.mutation)({
+    args: {
+        workspaceId: values_1.v.id('workspaces'),
+        userId: values_1.v.id('users'),
+    },
+    handler: async (ctx, { workspaceId, userId }) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            throw new Error('Not authenticated');
+        const currentUser = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!currentUser)
+            throw new Error('User not found');
+        const workspace = await ctx.db.get(workspaceId);
+        if (!workspace)
+            throw new Error('Workspace not found');
+        // Check permission (owner/admin can remove, or self-remove)
+        const isSelfRemove = userId === currentUser._id;
+        let canRemove = isSelfRemove || workspace.ownerId === currentUser._id;
+        if (!canRemove) {
+            const membership = await ctx.db
+                .query('workspaceMembers')
+                .withIndex('by_workspace_user', (q) => q.eq('workspaceId', workspaceId).eq('userId', currentUser._id))
+                .first();
+            canRemove = ['owner', 'admin'].includes(membership?.role || '');
+        }
+        if (!canRemove)
+            throw new Error('No permission to remove members');
+        // Find and delete membership
+        const membershipToRemove = await ctx.db
+            .query('workspaceMembers')
+            .withIndex('by_workspace_user', (q) => q.eq('workspaceId', workspaceId).eq('userId', userId))
+            .first();
+        if (!membershipToRemove) {
+            throw new Error('User is not a member of this workspace');
+        }
+        // Can't remove the last owner
+        if (membershipToRemove.role === 'owner') {
+            const ownerCount = await ctx.db
+                .query('workspaceMembers')
+                .withIndex('by_workspace', (q) => q.eq('workspaceId', workspaceId))
+                .filter((q) => q.eq(q.field('role'), 'owner'))
+                .collect();
+            if (ownerCount.length <= 1) {
+                throw new Error('Cannot remove the last owner of a workspace');
+            }
+        }
+        await ctx.db.delete(membershipToRemove._id);
+        // Update member count
+        await ctx.db.patch(workspaceId, {
+            memberCount: Math.max((workspace.memberCount || 1) - 1, 0),
+            updatedAt: Date.now(),
+        });
+        return { success: true };
+    },
+});
+/**
+ * Delete a workspace
+ */
+exports.remove = (0, server_1.mutation)({
+    args: { workspaceId: values_1.v.id('workspaces') },
+    handler: async (ctx, { workspaceId }) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            throw new Error('Not authenticated');
+        const user = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!user)
+            throw new Error('User not found');
+        const workspace = await ctx.db.get(workspaceId);
+        if (!workspace)
+            throw new Error('Workspace not found');
+        // Can't delete default workspace
+        if (workspace.isDefault) {
+            throw new Error('Cannot delete your default personal workspace');
+        }
+        // Only owner can delete
+        if (workspace.ownerId !== user._id) {
+            throw new Error('Only the workspace owner can delete it');
+        }
+        // Delete all workspace members
+        const members = await ctx.db
+            .query('workspaceMembers')
+            .withIndex('by_workspace', (q) => q.eq('workspaceId', workspaceId))
+            .collect();
+        for (const member of members) {
+            await ctx.db.delete(member._id);
+        }
+        // Note: In production, you'd also want to handle:
+        // - Moving/archiving chats
+        // - Moving/archiving flows
+        // - Disconnecting integrations
+        // For now, we'll just delete the workspace
+        await ctx.db.delete(workspaceId);
+        // If this was user's active workspace, switch to default
+        if (user.activeWorkspaceId === workspaceId) {
+            const defaultWorkspace = await ctx.db
+                .query('workspaces')
+                .withIndex('by_owner', (q) => q.eq('ownerId', user._id))
+                .filter((q) => q.eq(q.field('isDefault'), true))
+                .first();
+            if (defaultWorkspace) {
+                await ctx.db.patch(user._id, {
+                    activeWorkspaceId: defaultWorkspace._id,
+                });
+            }
+        }
+        return { success: true };
+    },
+});
+/**
+ * Get workspace context for V0.1.0 CRM
+ * Returns workspace info. Missions removed in V0.1.0 schema migration.
+ */
+exports.getContext = (0, server_1.query)({
+    args: { workspaceId: values_1.v.id('workspaces') },
+    handler: async (ctx, args) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            return null;
+        const workspace = await ctx.db.get(args.workspaceId);
+        if (!workspace)
+            return null;
+        return {
+            workspaceName: workspace.name,
+        };
+    },
+});

package/dist/mcp-server/lib/convexClient.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * VantageCRM MCP Server — Convex HTTP Client wrapper
+ *
+ * Provides a typed wrapper around ConvexHttpClient for use in MCP tool handlers.
+ * The MCP server is a standalone Node process — it calls Convex over HTTP.
+ *
+ * Environment variables:
+ *   CONVEX_URL        — required, e.g. https://your-deployment.convex.cloud
+ *   CONVEX_AUTH_TOKEN — optional, used for system-level Convex auth in HTTP mode
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConvexClient = getConvexClient;
+exports.ok = ok;
+exports.err = err;
+exports.withEnvelope = withEnvelope;
+const browser_1 = require("convex/browser");
+let _client = null;
+function getConvexClient() {
+    if (_client)
+        return _client;
+    const url = process.env.CONVEX_URL;
+    if (!url) {
+        throw new Error('CONVEX_URL environment variable is required');
+    }
+    _client = new browser_1.ConvexHttpClient(url);
+    return _client;
+}
+function ok(data) {
+    return { success: true, data };
+}
+function err(code, message) {
+    return { success: false, error: { code, message } };
+}
+/**
+ * Wrap a tool handler with standard try/catch envelope.
+ * Returns ToolResult in all cases — never throws.
+ */
+async function withEnvelope(fn) {
+    try {
+        const data = await fn();
+        return ok(data);
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        const code = e instanceof Error && e.name !== 'Error' ? e.name : 'CONVEX_ERROR';
+        // Cast: error path returns ToolResult with no data, compatible with ToolResult<T>
+        return { success: false, error: { code, message } };
+    }
+}