@vantageos/vantage-crm-mcp 0.1.0

package/dist/mcp-server/tools/rbac.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * VantageCRM MCP — RBAC tools (5 tools)
+ *
+ * Tools: list_workspace_members, add_workspace_member, update_member_role,
+ *        remove_workspace_member, update_member_permissions
+ *
+ * Scope: read for list, admin for mutations
+ * Ref: spec §3.11
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RBAC_TOOLS = void 0;
+exports.list_workspace_members = list_workspace_members;
+exports.add_workspace_member = add_workspace_member;
+exports.update_member_role = update_member_role;
+exports.remove_workspace_member = remove_workspace_member;
+exports.update_member_permissions = update_member_permissions;
+const zod_1 = require("zod");
+const api_1 = require("../../convex/_generated/api");
+const convexClient_1 = require("../lib/convexClient");
+// ---------------------------------------------------------------------------
+// Zod schemas
+// ---------------------------------------------------------------------------
+const MEMBER_ROLES = ['owner', 'admin', 'editor', 'viewer'];
+const ListWorkspaceMembersSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+});
+const AddWorkspaceMemberSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+    userId: zod_1.z.string().min(1),
+    role: zod_1.z.enum(MEMBER_ROLES).default('editor'),
+});
+const UpdateMemberRoleSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+    userId: zod_1.z.string().min(1),
+    newRole: zod_1.z.enum(MEMBER_ROLES),
+});
+const RemoveWorkspaceMemberSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+    userId: zod_1.z.string().min(1),
+});
+const UpdateMemberPermissionsSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+    userId: zod_1.z.string().min(1),
+    permissions: zod_1.z.object({
+        canExportData: zod_1.z.boolean().optional(),
+        canManageIntegrations: zod_1.z.boolean().optional(),
+        canManageBilling: zod_1.z.boolean().optional(),
+        canInviteMembers: zod_1.z.boolean().optional(),
+        canManageWorkflows: zod_1.z.boolean().optional(),
+    }),
+});
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+async function list_workspace_members(rawArgs) {
+    const args = ListWorkspaceMembersSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().query(api_1.api.workspaces.getMembers, {
+        workspaceId: args.workspaceId,
+    }));
+}
+async function add_workspace_member(rawArgs) {
+    const args = AddWorkspaceMemberSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().mutation(api_1.api.workspaces.addMember, {
+        workspaceId: args.workspaceId,
+        userId: args.userId,
+        role: args.role,
+    }));
+}
+async function update_member_role(rawArgs) {
+    UpdateMemberRoleSchema.parse(rawArgs);
+    // Dedicated updateRole mutation not yet in V0.1.0 — stable NOT_IMPLEMENTED envelope
+    return {
+        success: false,
+        error: {
+            code: 'NOT_IMPLEMENTED',
+            message: 'update_member_role: reserved for V0.2. Use add_workspace_member with the new role to update.',
+        },
+    };
+}
+async function remove_workspace_member(rawArgs) {
+    const args = RemoveWorkspaceMemberSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().mutation(api_1.api.workspaces.removeMember, {
+        workspaceId: args.workspaceId,
+        userId: args.userId,
+    }));
+}
+async function update_member_permissions(rawArgs) {
+    UpdateMemberPermissionsSchema.parse(rawArgs);
+    // Dedicated updatePermissions mutation not yet in V0.1.0 — stable NOT_IMPLEMENTED envelope
+    return {
+        success: false,
+        error: {
+            code: 'NOT_IMPLEMENTED',
+            message: 'update_member_permissions: reserved for V0.2. Requires crm.rbac.updatePermissions mutation.',
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+exports.RBAC_TOOLS = [
+    {
+        name: 'list_workspace_members',
+        description: 'List all members of a workspace with their roles',
+        requiredScope: 'read',
+        inputSchema: {
+            type: 'object',
+            properties: { workspaceId: { type: 'string' } },
+            required: ['workspaceId'],
+        },
+    },
+    {
+        name: 'add_workspace_member',
+        description: 'Invite a user to a workspace and assign a role (admin only)',
+        requiredScope: 'admin',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: { type: 'string' },
+                userId: { type: 'string' },
+                role: { type: 'string', enum: ['owner', 'admin', 'editor', 'viewer'] },
+            },
+            required: ['workspaceId', 'userId'],
+        },
+    },
+    {
+        name: 'update_member_role',
+        description: 'Change a member\'s role in a workspace (admin only)',
+        requiredScope: 'admin',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: { type: 'string' },
+                userId: { type: 'string' },
+                newRole: { type: 'string', enum: ['owner', 'admin', 'editor', 'viewer'] },
+            },
+            required: ['workspaceId', 'userId', 'newRole'],
+        },
+    },
+    {
+        name: 'remove_workspace_member',
+        description: 'Remove a member from a workspace (admin only)',
+        requiredScope: 'admin',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: { type: 'string' },
+                userId: { type: 'string' },
+            },
+            required: ['workspaceId', 'userId'],
+        },
+    },
+    {
+        name: 'update_member_permissions',
+        description: 'Set granular permission overrides for a workspace member (admin only)',
+        requiredScope: 'admin',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: { type: 'string' },
+                userId: { type: 'string' },
+                permissions: {
+                    type: 'object',
+                    properties: {
+                        canExportData: { type: 'boolean' },
+                        canManageIntegrations: { type: 'boolean' },
+                        canManageBilling: { type: 'boolean' },
+                        canInviteMembers: { type: 'boolean' },
+                        canManageWorkflows: { type: 'boolean' },
+                    },
+                },
+            },
+            required: ['workspaceId', 'userId', 'permissions'],
+        },
+    },
+];

package/dist/mcp-server/tools/search.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * VantageCRM MCP — Search / Analytics tools (4 tools)
+ *
+ * Tools: pipeline_value, win_rate, conversion_rate, activity_summary
+ *
+ * All analytics are read-only.
+ * Scope: read
+ * Ref: spec §3.9
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEARCH_TOOLS = void 0;
+exports.pipeline_value = pipeline_value;
+exports.win_rate = win_rate;
+exports.conversion_rate = conversion_rate;
+exports.activity_summary = activity_summary;
+const zod_1 = require("zod");
+const api_1 = require("../../convex/_generated/api");
+const convexClient_1 = require("../lib/convexClient");
+// ---------------------------------------------------------------------------
+// Zod schemas
+// ---------------------------------------------------------------------------
+const PipelineValueSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+});
+const WinRateSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+    since: zod_1.z.number().optional(),
+    until: zod_1.z.number().optional(),
+});
+const ConversionRateSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+    since: zod_1.z.number().optional(),
+    until: zod_1.z.number().optional(),
+});
+const ActivitySummarySchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+    ownerId: zod_1.z.string().optional(),
+    since: zod_1.z.number().optional(),
+    until: zod_1.z.number().optional(),
+});
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+async function pipeline_value(rawArgs) {
+    const args = PipelineValueSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().query(api_1.api.crm.deals.forecast, {
+        workspaceId: args.workspaceId,
+    }));
+}
+async function win_rate(rawArgs) {
+    const args = WinRateSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().query(api_1.api.crm.stats.conversionRate, {
+        workspaceId: args.workspaceId,
+        startDate: args.since,
+        endDate: args.until,
+    }));
+}
+async function conversion_rate(rawArgs) {
+    const args = ConversionRateSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().query(api_1.api.crm.stats.conversionRate, {
+        workspaceId: args.workspaceId,
+        startDate: args.since,
+        endDate: args.until,
+    }));
+}
+async function activity_summary(rawArgs) {
+    const args = ActivitySummarySchema.parse(rawArgs);
+    // activities.summary is crm.deals.summary (pipeline) — use list + aggregate
+    return (0, convexClient_1.withEnvelope)(async () => {
+        const activities = await (0, convexClient_1.getConvexClient)().query(api_1.api.crm.activities.list, {
+            workspaceId: args.workspaceId,
+            limit: 500,
+        });
+        let results = activities;
+        if (args.ownerId !== undefined) {
+            results = results.filter((a) => a['ownerId'] === args.ownerId);
+        }
+        if (args.since !== undefined) {
+            results = results.filter((a) => a['occurredAt'] >= args.since);
+        }
+        if (args.until !== undefined) {
+            results = results.filter((a) => a['occurredAt'] <= args.until);
+        }
+        // Aggregate by type
+        const byType = {};
+        for (const a of results) {
+            const t = String(a['type'] ?? 'unknown');
+            byType[t] = (byType[t] ?? 0) + 1;
+        }
+        return {
+            total: results.length,
+            byType,
+            ownerId: args.ownerId ?? 'all',
+        };
+    });
+}
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+exports.SEARCH_TOOLS = [
+    {
+        name: 'pipeline_value',
+        description: 'Compute weighted pipeline value (Σ value × probability) for a workspace',
+        requiredScope: 'read',
+        inputSchema: {
+            type: 'object',
+            properties: { workspaceId: { type: 'string' } },
+            required: ['workspaceId'],
+        },
+    },
+    {
+        name: 'win_rate',
+        description: 'Win rate: deals won / total closed deals in a period',
+        requiredScope: 'read',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: { type: 'string' },
+                since: { type: 'number', description: 'Unix ms start' },
+                until: { type: 'number', description: 'Unix ms end' },
+            },
+            required: ['workspaceId'],
+        },
+    },
+    {
+        name: 'conversion_rate',
+        description: 'Stage conversion rate for a workspace over a time period',
+        requiredScope: 'read',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: { type: 'string' },
+                since: { type: 'number' },
+                until: { type: 'number' },
+            },
+            required: ['workspaceId'],
+        },
+    },
+    {
+        name: 'activity_summary',
+        description: 'Activity count summary grouped by type, optionally filtered by owner/period',
+        requiredScope: 'read',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: { type: 'string' },
+                ownerId: { type: 'string' },
+                since: { type: 'number' },
+                until: { type: 'number' },
+            },
+            required: ['workspaceId'],
+        },
+    },
+];

package/dist/mcp-server/tools/workflows.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * VantageCRM MCP — Workflows tools (7 tools)
+ *
+ * Tools: create_workflow, update_workflow, list_workflows, pause_workflow,
+ *        resume_workflow, list_executions, replay_execution
+ *
+ * Scope: read for queries, write for mutations, workflow-trigger for replay
+ * Ref: spec §3.8
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKFLOW_TOOLS = void 0;
+exports.create_workflow = create_workflow;
+exports.update_workflow = update_workflow;
+exports.list_workflows = list_workflows;
+exports.pause_workflow = pause_workflow;
+exports.resume_workflow = resume_workflow;
+exports.list_executions = list_executions;
+exports.replay_execution = replay_execution;
+const zod_1 = require("zod");
+const server_1 = require("convex/server");
+const convexClient_1 = require("../lib/convexClient");
+// ---------------------------------------------------------------------------
+// Zod schemas
+// ---------------------------------------------------------------------------
+const CreateWorkflowSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+    name: zod_1.z.string().min(1).max(200),
+    description: zod_1.z.string().max(1000).optional(),
+    trigger: zod_1.z.object({
+        type: zod_1.z.string().min(1),
+        config: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+    }),
+    actions: zod_1.z.array(zod_1.z.object({
+        type: zod_1.z.string().min(1),
+        config: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+        order: zod_1.z.number().int().min(0),
+    })),
+});
+const UpdateWorkflowSchema = zod_1.z.object({
+    workflowId: zod_1.z.string().min(1),
+    name: zod_1.z.string().min(1).max(200).optional(),
+    description: zod_1.z.string().max(1000).optional(),
+    trigger: zod_1.z.object({
+        type: zod_1.z.string().min(1),
+        config: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+    }).optional(),
+    actions: zod_1.z.array(zod_1.z.object({
+        type: zod_1.z.string().min(1),
+        config: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+        order: zod_1.z.number().int().min(0),
+    })).optional(),
+});
+const ListWorkflowsSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+    isActive: zod_1.z.boolean().optional(),
+});
+const PauseWorkflowSchema = zod_1.z.object({
+    workflowId: zod_1.z.string().min(1),
+    reason: zod_1.z.string().max(500).optional(),
+});
+const ResumeWorkflowSchema = zod_1.z.object({
+    workflowId: zod_1.z.string().min(1),
+});
+const ListExecutionsSchema = zod_1.z.object({
+    workspaceId: zod_1.z.string().min(1),
+    workflowId: zod_1.z.string().optional(),
+    status: zod_1.z.enum(['pending', 'running', 'completed', 'failed', 'cancelled']).optional(),
+    limit: zod_1.z.number().int().min(1).max(100).default(20),
+});
+const ReplayExecutionSchema = zod_1.z.object({
+    executionId: zod_1.z.string().min(1),
+});
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+async function create_workflow(rawArgs) {
+    const args = CreateWorkflowSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().mutation(server_1.anyApi.crm.workflows.createWorkflowDefinition, {
+        workspaceId: args.workspaceId,
+        name: args.name,
+        description: args.description,
+        trigger: args.trigger,
+        actions: args.actions,
+    }));
+}
+async function update_workflow(rawArgs) {
+    const args = UpdateWorkflowSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().mutation(server_1.anyApi.crm.workflows.updateWorkflowDefinition, {
+        workflowId: args.workflowId,
+        name: args.name,
+        description: args.description,
+        trigger: args.trigger,
+        actions: args.actions,
+    }));
+}
+async function list_workflows(rawArgs) {
+    const args = ListWorkflowsSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().query(server_1.anyApi.crm.workflows.listWorkflowDefinitions, {
+        workspaceId: args.workspaceId,
+        isActive: args.isActive,
+    }));
+}
+async function pause_workflow(rawArgs) {
+    const args = PauseWorkflowSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().mutation(server_1.anyApi.crm.workflows.disableWorkflow, {
+        workflowId: args.workflowId,
+        reason: args.reason,
+    }));
+}
+async function resume_workflow(rawArgs) {
+    const args = ResumeWorkflowSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().mutation(server_1.anyApi.crm.workflows.enableWorkflow, {
+        workflowId: args.workflowId,
+    }));
+}
+async function list_executions(rawArgs) {
+    const args = ListExecutionsSchema.parse(rawArgs);
+    return (0, convexClient_1.withEnvelope)(() => (0, convexClient_1.getConvexClient)().query(server_1.anyApi.crm.workflows.listWorkflowExecutions, {
+        workspaceId: args.workspaceId,
+        workflowId: args.workflowId,
+        status: args.status,
+        limit: args.limit,
+    }));
+}
+async function replay_execution(rawArgs) {
+    ReplayExecutionSchema.parse(rawArgs);
+    // replayExecution not yet in Convex layer V0.1.0 — stable NOT_IMPLEMENTED envelope
+    return {
+        success: false,
+        error: {
+            code: 'NOT_IMPLEMENTED',
+            message: 'replay_execution: reserved for V0.2. Requires crm.workflows.replayExecution mutation.',
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+exports.WORKFLOW_TOOLS = [
+    {
+        name: 'create_workflow',
+        description: 'Create a workflow definition with trigger and actions',
+        requiredScope: 'write',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: { type: 'string' },
+                name: { type: 'string' },
+                description: { type: 'string' },
+                trigger: { type: 'object', properties: { type: { type: 'string' }, config: { type: 'object' } }, required: ['type', 'config'] },
+                actions: { type: 'array', items: { type: 'object' } },
+            },
+            required: ['workspaceId', 'name', 'trigger', 'actions'],
+        },
+    },
+    {
+        name: 'update_workflow',
+        description: 'Update a workflow definition (must be disabled first)',
+        requiredScope: 'write',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: { type: 'string' },
+                name: { type: 'string' },
+                description: { type: 'string' },
+                trigger: { type: 'object' },
+                actions: { type: 'array' },
+            },
+            required: ['workflowId'],
+        },
+    },
+    {
+        name: 'list_workflows',
+        description: 'List workflow definitions, optionally filtered by active status',
+        requiredScope: 'read',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: { type: 'string' },
+                isActive: { type: 'boolean' },
+            },
+            required: ['workspaceId'],
+        },
+    },
+    {
+        name: 'pause_workflow',
+        description: 'Pause (disable) a workflow — sets isActive=false',
+        requiredScope: 'write',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: { type: 'string' },
+                reason: { type: 'string' },
+            },
+            required: ['workflowId'],
+        },
+    },
+    {
+        name: 'resume_workflow',
+        description: 'Resume (enable) a workflow — sets isActive=true',
+        requiredScope: 'write',
+        inputSchema: {
+            type: 'object',
+            properties: { workflowId: { type: 'string' } },
+            required: ['workflowId'],
+        },
+    },
+    {
+        name: 'list_executions',
+        description: 'List workflow executions by workspace/workflow/status',
+        requiredScope: 'read',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: { type: 'string' },
+                workflowId: { type: 'string' },
+                status: { type: 'string', enum: ['pending', 'running', 'completed', 'failed', 'cancelled'] },
+                limit: { type: 'number' },
+            },
+            required: ['workspaceId'],
+        },
+    },
+    {
+        name: 'replay_execution',
+        description: 'Replay a workflow execution (requires workflow-trigger scope)',
+        requiredScope: 'workflow-trigger',
+        inputSchema: {
+            type: 'object',
+            properties: { executionId: { type: 'string' } },
+            required: ['executionId'],
+        },
+    },
+];