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

package/dist/index.js

@@ -49115,11 +49115,15 @@ function isJwtExpired(jwt2) {
   }
 }
 async function refreshSupabaseJwt(ctx) {
-  if (!ctx.supabaseRefreshToken)
+  if (!ctx.supabaseRefreshToken) {
+    console.error("[JWT Refresh] No refresh token available, cannot refresh");
     return;
+  }
   const supabaseUrl = process.env.SUPABASE_URL;
-  if (!supabaseUrl)
+  if (!supabaseUrl) {
+    console.error("[JWT Refresh] SUPABASE_URL not set, cannot refresh");
     return;
+  }
   try {
     const res = await fetch(`${supabaseUrl}/auth/v1/token?grant_type=refresh_token`, {
       method: "POST",
@@ -49129,14 +49133,19 @@ async function refreshSupabaseJwt(ctx) {
       },
       body: JSON.stringify({ refresh_token: ctx.supabaseRefreshToken })
     });
-    if (!res.ok)
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      console.error(`[JWT Refresh] Supabase returned ${res.status}: ${body}`);
       return;
+    }
     const data = await res.json();
     ctx.supabaseJwt = data.access_token;
     ctx.supabaseRefreshToken = data.refresh_token;
     ctx.client.setBearerToken(data.access_token);
+    console.error("[JWT Refresh] Token refreshed successfully");
     return data.access_token;
-  } catch {
+  } catch (error48) {
+    console.error("[JWT Refresh] Failed:", error48);
     return;
   }
 }
@@ -49231,18 +49240,19 @@ function classifyError(error48) {
   }
   return "Unknown error";
 }
-function withErrorHandling(name, handler) {
-  return async (...args) => {
-    try {
-      return await handler(...args);
-    } catch (error48) {
-      const message = classifyError(error48);
-      console.error(`[Tool Error] ${name}:`, error48);
-      return errorResult(message);
-    }
-  };
-}
 function registerTools(server, ctx) {
+  function withErrorHandling(name, handler) {
+    return async (...args) => {
+      try {
+        await getValidJwt(ctx);
+        return await handler(...args);
+      } catch (error48) {
+        const message = classifyError(error48);
+        console.error(`[Tool Error] ${name}:`, error48);
+        return errorResult(message);
+      }
+    };
+  }
   server.registerTool("whoami", {
     description: "Show current user details: email, authentication method, and team memberships",
     inputSchema: {},
@@ -49540,6 +49550,183 @@ 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.array(exports_external.string()).describe('Event types to notify on. Pass ["all"] for all events, or pick from: ' + "workflow_started, workflow_finished, workflow_failed, workflow_sample_finished, " + "workflow_data_change, system_maintenance, service_degradation, credits_low, free_trial_ending"),
+      channels: exports_external.object({
+        email: exports_external.object({
+          recipients: exports_external.array(exports_external.string().email()).optional().describe("Email addresses to notify. Omit to use the account default email.")
+        }).optional().describe("Send email notifications. Pass {} for default email or {recipients: [...]} for custom addresses."),
+        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 events = args.events.length === 1 && args.events[0] === "all" ? "all" : args.events;
+    const channelSetup = {};
+    const ch = args.channels;
+    if (ch.email) {
+      if (ch.email.recipients?.length) {
+        channelSetup.EMAIL = { name: "mcp-email", recipients: ch.email.recipients };
+      } else {
+        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,
+      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: ${events === "all" ? "all" : events.join(", ")}. 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.2",
   "description": "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
   "type": "module",
   "main": "dist/index.js",