@kadoa/mcp 0.3.4-rc.0 → 0.3.4-rc.1

package/dist/index.js

@@ -49540,6 +49540,188 @@ function registerTools(server, ctx) {
       workflow: result
     });
   }));
+  server.registerTool("list_notification_channels", {
+    description: "List notification channels configured for a workflow or across the workspace. Channels are destinations (email, Slack, webhook, websocket) where notifications are sent.",
+    inputSchema: {
+      workflowId: exports_external.string().optional().describe("Filter channels linked to a specific workflow. Omit to list all workspace channels.")
+    },
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+  }, withErrorHandling("list_notification_channels", async (args) => {
+    const channels = args.workflowId ? await ctx.client.notification.channels.listAllChannels(args.workflowId) : await ctx.client.notification.channels.listAllChannels();
+    return jsonResult({
+      channels: channels.map((ch) => ({
+        id: ch.id,
+        name: ch.name,
+        channelType: ch.channelType,
+        config: ch.config,
+        linkedConfigurations: ch.linkedConfigurations,
+        createdAt: ch.createdAt
+      })),
+      total: channels.length
+    });
+  }));
+  server.registerTool("create_notification_channel", {
+    description: "Create a notification channel (email, webhook, or slack). The channel can then be linked to notification settings for specific events.",
+    inputSchema: {
+      channelType: exports_external.enum(["EMAIL", "WEBHOOK", "SLACK"]).describe("Type of notification channel"),
+      name: exports_external.string().optional().describe("Name for the channel (defaults to 'default')"),
+      config: exports_external.object({
+        recipients: exports_external.array(exports_external.string()).optional().describe("Email recipients (required for EMAIL channels)"),
+        webhookUrl: exports_external.string().optional().describe("Webhook/Slack endpoint URL (required for WEBHOOK and SLACK channels)"),
+        httpMethod: exports_external.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method for WEBHOOK channels (defaults to POST)")
+      }).optional().describe("Channel-specific configuration. For EMAIL: provide recipients. For WEBHOOK: provide webhookUrl. For SLACK: provide webhookUrl.")
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("create_notification_channel", async (args) => {
+    const channel = await ctx.client.notification.channels.createChannel(args.channelType, {
+      name: args.name || "default",
+      config: args.config
+    });
+    return jsonResult({
+      success: true,
+      channel: {
+        id: channel.id,
+        name: channel.name,
+        channelType: channel.channelType,
+        config: channel.config
+      },
+      message: `${args.channelType} notification channel created successfully.`
+    });
+  }));
+  server.registerTool("delete_notification_channel", {
+    description: "Delete a notification channel by ID",
+    inputSchema: {
+      channelId: exports_external.string().describe("The channel ID to delete")
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
+  }, withErrorHandling("delete_notification_channel", async (args) => {
+    await ctx.client.notification.channels.deleteChannel(args.channelId);
+    return jsonResult({
+      success: true,
+      message: "Notification channel deleted successfully."
+    });
+  }));
+  server.registerTool("list_notification_settings", {
+    description: "List notification settings (event-to-channel mappings) for a workflow or workspace. Shows which events trigger notifications and through which channels.",
+    inputSchema: {
+      workflowId: exports_external.string().optional().describe("Filter settings for a specific workflow. Omit to list workspace-level settings."),
+      eventType: exports_external.enum([
+        "workflow_started",
+        "workflow_finished",
+        "workflow_failed",
+        "workflow_sample_finished",
+        "workflow_data_change",
+        "system_maintenance",
+        "service_degradation",
+        "credits_low",
+        "free_trial_ending"
+      ]).optional().describe("Filter by event type")
+    },
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+  }, withErrorHandling("list_notification_settings", async (args) => {
+    const filters = {};
+    if (args.workflowId)
+      filters.workflowId = args.workflowId;
+    if (args.eventType)
+      filters.eventType = args.eventType;
+    const settings = await ctx.client.notification.settings.listSettings(filters);
+    return jsonResult({
+      settings: settings.map((s) => ({
+        id: s.id,
+        workflowId: s.workflowId,
+        eventType: s.eventType,
+        enabled: s.enabled,
+        channels: s.channels,
+        createdAt: s.createdAt
+      })),
+      total: settings.length
+    });
+  }));
+  server.registerTool("configure_notifications", {
+    description: "Set up notifications for a workflow or workspace. Creates channels and settings in one step. " + "Specify which events to listen for and which channels to deliver to (email, webhook, slack, websocket).",
+    inputSchema: {
+      workflowId: exports_external.string().optional().describe("Workflow ID to configure notifications for. Omit for workspace-level notifications."),
+      events: exports_external.union([
+        exports_external.array(exports_external.enum([
+          "workflow_started",
+          "workflow_finished",
+          "workflow_failed",
+          "workflow_sample_finished",
+          "workflow_data_change",
+          "system_maintenance",
+          "service_degradation",
+          "credits_low",
+          "free_trial_ending"
+        ])),
+        exports_external.literal("all")
+      ]).describe('Event types to notify on, or "all" for all events'),
+      channels: exports_external.object({
+        email: exports_external.boolean().optional().describe("Send to user's default email address"),
+        webhook: exports_external.object({
+          url: exports_external.string().url().describe("Webhook endpoint URL"),
+          httpMethod: exports_external.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method (defaults to POST)")
+        }).optional().describe("Send via HTTP webhook"),
+        slack: exports_external.object({
+          webhookUrl: exports_external.string().url().describe("Slack incoming webhook URL")
+        }).optional().describe("Send to Slack channel"),
+        websocket: exports_external.boolean().optional().describe("Enable WebSocket notifications")
+      }).describe("At least one channel must be specified")
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("configure_notifications", async (args) => {
+    const channelSetup = {};
+    const ch = args.channels;
+    if (ch.email)
+      channelSetup.EMAIL = true;
+    if (ch.websocket)
+      channelSetup.WEBSOCKET = true;
+    if (ch.webhook) {
+      channelSetup.WEBHOOK = {
+        name: "mcp-webhook",
+        webhookUrl: ch.webhook.url,
+        httpMethod: ch.webhook.httpMethod || "POST"
+      };
+    }
+    if (ch.slack) {
+      channelSetup.SLACK = {
+        name: "mcp-slack",
+        webhookUrl: ch.slack.webhookUrl
+      };
+    }
+    if (Object.keys(channelSetup).length === 0) {
+      return errorResult("At least one notification channel must be specified (email, webhook, slack, or websocket).");
+    }
+    const settings = await ctx.client.notification.configure({
+      workflowId: args.workflowId,
+      events: args.events,
+      channels: channelSetup
+    });
+    const enabledChannels = Object.keys(channelSetup).map((k) => k.toLowerCase());
+    const scope = args.workflowId ? `workflow ${args.workflowId}` : "workspace";
+    return jsonResult({
+      success: true,
+      message: `Notifications configured for ${scope}. Events: ${Array.isArray(args.events) ? args.events.join(", ") : args.events}. Channels: ${enabledChannels.join(", ")}.`,
+      settings: settings.map((s) => ({
+        id: s.id,
+        eventType: s.eventType,
+        enabled: s.enabled,
+        channels: s.channels
+      }))
+    });
+  }));
+  server.registerTool("delete_notification_setting", {
+    description: "Delete a notification setting by ID. This removes the event-to-channel mapping but does not delete the channels themselves.",
+    inputSchema: {
+      settingsId: exports_external.string().describe("The notification settings ID to delete")
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
+  }, withErrorHandling("delete_notification_setting", async (args) => {
+    await ctx.client.notification.settings.deleteSettings(args.settingsId);
+    return jsonResult({
+      success: true,
+      message: "Notification setting deleted successfully."
+    });
+  }));
   server.registerTool("team_list", {
     description: "List all teams the current user belongs to, showing which team is currently active",
     inputSchema: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kadoa/mcp",
-  "version": "0.3.4-rc.0",
+  "version": "0.3.4-rc.1",
   "description": "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
   "type": "module",
   "main": "dist/index.js",