conduyt-mcp 4.1.0

package/dist/tools/webhooks.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { formatResult } from "../client.js";
+export function registerWebhookTools(server, client) {
+    server.tool("conduyt_list_webhooks", "List all registered webhooks with their events, status, and failure counts.", {
+        page: z.number().optional().describe("Page number (default 1)"),
+        per_page: z.number().optional().describe("Results per page"),
+    }, async ({ page, per_page }) => {
+        const params = new URLSearchParams();
+        if (page)
+            params.set("page", String(page));
+        if (per_page)
+            params.set("per_page", String(per_page));
+        const result = await client.get(`/api/v1/webhooks/manage?${params}`);
+        return formatResult(result);
+    });
+    server.tool("conduyt_create_webhook", "Register a new webhook endpoint. Returns the signing secret once — store it securely. Events: contact.created/updated/deleted, contact.tag_added/removed, deal.created/updated/stage_changed/won/lost/deleted, company.created/updated/deleted, message.sent/received, appointment.created/updated/cancelled, campaign.completed.", {
+        url: z.string().describe("Webhook endpoint URL (HTTPS required in production)"),
+        events: z.array(z.string()).describe("Events to subscribe to (e.g. ['contact.created', 'deal.won'])"),
+        description: z.string().optional().describe("Human-readable description of this webhook"),
+        isActive: z.boolean().optional().describe("Whether webhook is active (default true)"),
+    }, async (params) => {
+        const result = await client.post("/api/v1/webhooks/manage", params);
+        return formatResult(result);
+    });
+    server.tool("conduyt_update_webhook", "Update a webhook — change URL, events, or enable/disable. Reactivating resets the failure count.", {
+        id: z.string().describe("Webhook UUID"),
+        url: z.string().optional().describe("Updated endpoint URL"),
+        events: z.array(z.string()).optional().describe("Updated event subscriptions"),
+        isActive: z.boolean().optional().describe("Enable or disable the webhook"),
+        description: z.string().optional().describe("Updated description"),
+    }, async ({ id, ...updates }) => {
+        const result = await client.patch(`/api/v1/webhooks/manage/${id}`, updates);
+        return formatResult(result);
+    });
+    server.tool("conduyt_delete_webhook", "Delete a webhook endpoint.", {
+        id: z.string().describe("Webhook UUID"),
+    }, async ({ id }) => {
+        const result = await client.del(`/api/v1/webhooks/manage/${id}`);
+        return formatResult(result);
+    });
+}

package/dist/tools/workflow-sandbox.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ConduytClient } from "../client.js";
+export declare function registerWorkflowSandboxTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/workflow-sandbox.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { formatResult } from "../client.js";
+function unwrap(response) {
+    if (response && typeof response === "object" && "data" in response) {
+        return response.data;
+    }
+    return response;
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function registerWorkflowSandboxTools(server, client) {
+    server.tool("conduyt_workflow_validate", "Validate a workflow graph WITHOUT saving it. Returns errors and warnings so you can fix issues before creating or publishing. Always call this before conduyt_workflow_promote.", {
+        triggerEvent: z.string().describe("Trigger event (e.g. 'contact.created', 'deal.stage_changed', 'tag.added', 'scheduled')"),
+        graph: z.object({
+            nodes: z.array(z.object({
+                id: z.string(),
+                type: z.string(),
+            }).passthrough()).describe("Array of graph nodes"),
+            startNodeId: z.string().describe("ID of the trigger/start node"),
+        }).describe("The workflow graph to validate"),
+    }, async ({ triggerEvent, graph }) => {
+        const result = await client.post("/api/v1/automations/validate", {
+            triggerEvent,
+            graph,
+        });
+        return formatResult(result);
+    });
+    server.tool("conduyt_workflow_simulate", "Dry-run a saved automation against a real or stub contact. Returns a step-by-step trace of what WOULD happen — no messages sent, no tags applied, no side effects. Checks compliance (DNC, opt-outs), provider readiness (SMS/email configured), and condition evaluation. Use this to verify a workflow does what you expect before publishing.", {
+        automationId: z.string().describe("Automation UUID to simulate"),
+        contactId: z.string().optional().describe("Contact UUID to simulate against. If omitted, uses a stub contact with empty fields."),
+    }, async ({ automationId, contactId }) => {
+        if (!UUID_RE.test(automationId)) {
+            return formatResult({ error: "automationId must be a valid UUID" });
+        }
+        if (contactId && !UUID_RE.test(contactId)) {
+            return formatResult({ error: "contactId must be a valid UUID" });
+        }
+        const body = {};
+        if (contactId)
+            body.contactId = contactId;
+        const result = await client.post(`/api/v1/automations/${automationId}/dry-run`, body);
+        return formatResult(result);
+    });
+    server.tool("conduyt_workflow_promote", "Safely publish a workflow. First validates the current graph — if there are errors, returns them and refuses to publish. If validation passes, publishes the draft to live. This is the recommended way to go live — it prevents broken workflows from reaching contacts.", {
+        automationId: z.string().describe("Automation UUID to promote to live"),
+        allowWarnings: z.boolean().optional().describe("Publish even if there are warnings (default true). Set false to block on warnings too."),
+    }, async ({ automationId, allowWarnings }) => {
+        if (!UUID_RE.test(automationId)) {
+            return formatResult({ promoted: false, error: "automationId must be a valid UUID" });
+        }
+        const rawAutomation = await client.get(`/api/v1/automations/${automationId}`);
+        const automation = unwrap(rawAutomation);
+        const graph = automation.actions;
+        const triggerEvent = automation.triggerEvent;
+        if (!graph || !triggerEvent) {
+            return formatResult({
+                promoted: false,
+                error: "Automation has no graph or trigger event defined. Save a draft first.",
+            });
+        }
+        const rawValidation = await client.post("/api/v1/automations/validate", {
+            triggerEvent,
+            graph,
+        });
+        const validation = unwrap(rawValidation);
+        if (!validation.valid) {
+            return formatResult({
+                promoted: false,
+                validation,
+                message: "Workflow has validation errors. Fix them before publishing.",
+            });
+        }
+        const hasWarnings = Array.isArray(validation.warnings) && validation.warnings.length > 0;
+        if (hasWarnings && allowWarnings === false) {
+            return formatResult({
+                promoted: false,
+                validation,
+                message: "Workflow has warnings and allowWarnings is false. Fix warnings or set allowWarnings to true.",
+            });
+        }
+        const published = await client.post(`/api/v1/automations/${automationId}/publish`, {});
+        return formatResult({
+            promoted: true,
+            warnings: hasWarnings ? validation.warnings : [],
+            message: hasWarnings
+                ? "Published with warnings — review them."
+                : "Workflow validated and published successfully.",
+            result: unwrap(published),
+        });
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,20 @@
+export interface ConduytConfig {
+    apiUrl: string;
+    apiKey: string;
+}
+export interface ApiResponse<T = unknown> {
+    data?: T;
+    meta?: {
+        page: number;
+        per_page: number;
+        total: number;
+    };
+    error?: string;
+}
+export type ToolContent = {
+    type: "text";
+    text: string;
+};
+export type ToolResult = {
+    content: ToolContent[];
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "conduyt-mcp",
+  "version": "4.1.0",
+  "description": "MCP server for Conduyt CRM — expose CRM operations as AI-accessible tools",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "conduyt-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    ".env.example"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "conduyt",
+    "crm",
+    "ai",
+    "claude",
+    "llm-tools"
+  ],
+  "homepage": "https://conduyt.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ptaramona/conduyt-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ptaramona/conduyt-mcp/issues"
+  },
+  "license": "MIT",
+  "author": "Conduyt",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "tsx": "^4.19.0",
+    "@types/node": "^22.0.0"
+  }
+}