cc-jandi 1.0.0

package/dist/services/IncomingWebhookService.js

@@ -0,0 +1,75 @@
+import { BaseWebhookService } from './base/BaseWebhookService.js';
+import { JandiColors, MessageType } from '../types/common.js';
+export class IncomingWebhookService extends BaseWebhookService {
+    static DEFAULT_URL = 'https://wh.jandi.com/connect-api/webhook';
+    buildUrl(config) {
+        return IncomingWebhookService.getWebhookUrl(config);
+    }
+    static getWebhookUrl(config) {
+        if (config.url) {
+            return config.url;
+        }
+        return `${this.DEFAULT_URL}/${config.token}`;
+    }
+    static async sendMessage(config, message) {
+        const url = this.getWebhookUrl(config);
+        return this.sendRequest(url, message);
+    }
+    static async validateToken(token, customUrl) {
+        const testMessage = {
+            body: 'Token validation test message',
+            connectColor: JandiColors.GRAY
+        };
+        const config = { token, url: customUrl };
+        try {
+            const result = await this.sendMessage(config, testMessage);
+            if (result.success) {
+                return {
+                    success: true,
+                    message: 'Token is valid'
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    error: `Token validation failed: ${result.error}`
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Token validation error: ${error}`
+            };
+        }
+    }
+    static createBasicMessage(body) {
+        return { body };
+    }
+    static createRichMessage(body, color, connectInfo) {
+        return {
+            body,
+            connectColor: color || JandiColors.DEFAULT,
+            connectInfo
+        };
+    }
+    static createStatusMessage(body, type, additionalInfo) {
+        const colorMap = {
+            [MessageType.INFO]: JandiColors.BLUE,
+            [MessageType.SUCCESS]: JandiColors.GREEN,
+            [MessageType.WARNING]: JandiColors.YELLOW,
+            [MessageType.ERROR]: JandiColors.RED
+        };
+        const message = {
+            body,
+            connectColor: colorMap[type]
+        };
+        if (additionalInfo) {
+            message.connectInfo = [{
+                    title: type.toUpperCase(),
+                    description: additionalInfo
+                }];
+        }
+        return message;
+    }
+}

package/dist/services/TeamIncomingWebhookService.js

@@ -0,0 +1,97 @@
+import { BaseWebhookService } from './base/BaseWebhookService.js';
+import { JandiColors } from '../types/common.js';
+export class TeamIncomingWebhookService extends BaseWebhookService {
+    static DEFAULT_URL = 'https://wh.jandi.com/connect-api/team-webhook';
+    static MAX_EMAIL_COUNT = 100;
+    buildUrl(config) {
+        return TeamIncomingWebhookService.getWebhookUrl(config);
+    }
+    static getWebhookUrl(config) {
+        if (config.url) {
+            return config.url;
+        }
+        return `${this.DEFAULT_URL}/${config.teamId}/${config.token}`;
+    }
+    static validateEmails(email) {
+        const emails = email.split(',').map(e => e.trim()).filter(e => e.length > 0);
+        if (emails.length === 0) {
+            return { valid: false, error: 'At least one email address is required' };
+        }
+        if (emails.length > this.MAX_EMAIL_COUNT) {
+            return {
+                valid: false,
+                error: `Maximum ${this.MAX_EMAIL_COUNT} email addresses allowed (provided: ${emails.length})`
+            };
+        }
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        const invalidEmails = emails.filter(e => !emailRegex.test(e));
+        if (invalidEmails.length > 0) {
+            return {
+                valid: false,
+                error: `Invalid email format: ${invalidEmails.join(', ')}`
+            };
+        }
+        return { valid: true };
+    }
+    static async sendMessage(config, message) {
+        const emailValidation = this.validateEmails(message.email);
+        if (!emailValidation.valid) {
+            return {
+                success: false,
+                error: emailValidation.error
+            };
+        }
+        const url = this.getWebhookUrl(config);
+        // Jandi Team Incoming Webhook uses 'to' field instead of 'email'
+        const payload = {
+            body: message.body,
+            connectColor: message.connectColor,
+            connectInfo: message.connectInfo,
+            to: message.email
+        };
+        return this.sendRequest(url, payload);
+    }
+    static async validateToken(config) {
+        const testMessage = {
+            body: 'Team webhook token validation test',
+            connectColor: JandiColors.GRAY,
+            email: ''
+        };
+        // For validation, we send a minimal request to check if the endpoint responds
+        const url = this.getWebhookUrl(config);
+        try {
+            const result = await this.sendRequest(url, {
+                body: testMessage.body,
+                connectColor: testMessage.connectColor
+            });
+            // Even if the message fails due to missing email, a 400 vs 401/403 tells us token validity
+            if (result.success) {
+                return { success: true, message: 'Team webhook token is valid' };
+            }
+            else if (result.errorCode === 40000) {
+                return { success: false, error: `Team webhook token validation failed: ${result.error}` };
+            }
+            else {
+                // Non-auth errors might mean the token is valid but request was incomplete
+                return { success: true, message: 'Team webhook token appears valid (endpoint reachable)' };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Team token validation error: ${error}`
+            };
+        }
+    }
+    static createBasicMessage(body, email) {
+        return { body, email };
+    }
+    static createRichMessage(body, email, color, connectInfo) {
+        return {
+            body,
+            email,
+            connectColor: color || JandiColors.DEFAULT,
+            connectInfo
+        };
+    }
+}

package/dist/services/base/BaseWebhookService.js

@@ -0,0 +1,90 @@
+import axios from 'axios';
+export class BaseWebhookService {
+    static HEADERS = {
+        'Accept': 'application/vnd.tosslab.jandi-v2+json',
+        'Content-Type': 'application/json'
+    };
+    static MAX_MESSAGE_LENGTH = 5000;
+    static MAX_DATA_SIZE = 256 * 1024; // 256KB
+    static REQUEST_TIMEOUT = 10000; // 10 seconds
+    static MAX_RETRIES = 3;
+    static RETRY_DELAYS = [5000, 15000, 30000]; // ms — Jandi rate limit is 60 req/min
+    static sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    static validateMessageLimits(message) {
+        if (message.body.length > this.MAX_MESSAGE_LENGTH) {
+            return {
+                valid: false,
+                error: `Message body exceeds maximum length of ${this.MAX_MESSAGE_LENGTH} characters (current: ${message.body.length})`
+            };
+        }
+        const dataSize = JSON.stringify(message).length;
+        if (dataSize > this.MAX_DATA_SIZE) {
+            return {
+                valid: false,
+                error: `Message data exceeds maximum size of ${this.MAX_DATA_SIZE} bytes (current: ${dataSize})`
+            };
+        }
+        return { valid: true };
+    }
+    static handleJandiError(error) {
+        if (error.response?.status === 429) {
+            return {
+                error: 'Rate limit exceeded. Jandi allows 60 requests/min and 500 requests/10min. Please wait and try again.',
+                errorCode: 42900,
+                rateLimited: true
+            };
+        }
+        if (error.response?.status === 400) {
+            const data = error.response.data;
+            if (data?.code === 40000) {
+                return {
+                    error: 'Invalid webhook token format or inactive/deleted webhook',
+                    errorCode: 40000
+                };
+            }
+            return {
+                error: 'Invalid request data format',
+                errorCode: 40000
+            };
+        }
+        return {
+            error: error.message || 'Unknown error occurred'
+        };
+    }
+    static async sendRequest(url, message) {
+        const validation = this.validateMessageLimits(message);
+        if (!validation.valid) {
+            return { success: false, error: validation.error };
+        }
+        let lastResult = { success: false, error: 'Max retries exceeded' };
+        for (let attempt = 0; attempt <= this.MAX_RETRIES; attempt++) {
+            if (attempt > 0) {
+                await this.sleep(this.RETRY_DELAYS[attempt - 1]);
+            }
+            try {
+                await axios.post(url, message, {
+                    headers: this.HEADERS,
+                    timeout: this.REQUEST_TIMEOUT
+                });
+                return { success: true, message: 'Message sent successfully' };
+            }
+            catch (error) {
+                const axiosError = error;
+                const errorInfo = this.handleJandiError(axiosError);
+                lastResult = {
+                    success: false,
+                    error: errorInfo.error,
+                    errorCode: errorInfo.errorCode,
+                    rateLimited: errorInfo.rateLimited
+                };
+                // Only retry on rate limit errors
+                if (!errorInfo.rateLimited) {
+                    return lastResult;
+                }
+            }
+        }
+        return lastResult;
+    }
+}

package/dist/services/configService.js

@@ -0,0 +1,125 @@
+import * as dotenv from 'dotenv';
+dotenv.config();
+export class ConfigService {
+    static tokens = new Map();
+    static teamTokens = new Map();
+    static outgoingTokens = new Map();
+    static initialize() {
+        // Load default incoming token
+        const defaultToken = process.env.JANDI_TOKEN;
+        if (defaultToken) {
+            this.addToken('default', defaultToken);
+        }
+        // Load named incoming tokens (JANDI_TOKEN_DEV, JANDI_TOKEN_PROD, etc.)
+        Object.keys(process.env).forEach(key => {
+            if (key.startsWith('JANDI_TOKEN_') && key !== 'JANDI_TOKEN') {
+                const alias = key.replace('JANDI_TOKEN_', '').toLowerCase();
+                const token = process.env[key];
+                if (token) {
+                    this.addToken(alias, token);
+                }
+            }
+        });
+        // Load custom URLs for incoming webhooks
+        Object.keys(process.env).forEach(key => {
+            if (key.startsWith('JANDI_URL_')) {
+                const alias = key.replace('JANDI_URL_', '').toLowerCase();
+                const url = process.env[key];
+                if (url && this.tokens.has(alias)) {
+                    const config = this.tokens.get(alias);
+                    config.url = url;
+                }
+            }
+        });
+        // Load team incoming tokens (JANDI_TEAM_ID_* + JANDI_TEAM_TOKEN_*)
+        const teamAliases = new Set();
+        Object.keys(process.env).forEach(key => {
+            if (key.startsWith('JANDI_TEAM_ID_')) {
+                teamAliases.add(key.replace('JANDI_TEAM_ID_', '').toLowerCase());
+            }
+            if (key.startsWith('JANDI_TEAM_TOKEN_')) {
+                teamAliases.add(key.replace('JANDI_TEAM_TOKEN_', '').toLowerCase());
+            }
+        });
+        teamAliases.forEach(alias => {
+            const teamId = process.env[`JANDI_TEAM_ID_${alias.toUpperCase()}`];
+            const token = process.env[`JANDI_TEAM_TOKEN_${alias.toUpperCase()}`];
+            if (teamId && token) {
+                const config = { teamId, token, alias };
+                const customUrl = process.env[`JANDI_TEAM_URL_${alias.toUpperCase()}`];
+                if (customUrl) {
+                    config.url = customUrl;
+                }
+                this.teamTokens.set(alias, config);
+            }
+        });
+        // Load outgoing verification tokens (JANDI_OUTGOING_TOKEN_*)
+        Object.keys(process.env).forEach(key => {
+            if (key.startsWith('JANDI_OUTGOING_TOKEN_')) {
+                const alias = key.replace('JANDI_OUTGOING_TOKEN_', '').toLowerCase();
+                const token = process.env[key];
+                if (token) {
+                    this.outgoingTokens.set(alias, token);
+                }
+            }
+        });
+    }
+    // --- Incoming Token Management ---
+    static addToken(alias, token, url) {
+        this.tokens.set(alias, {
+            token,
+            url,
+            alias
+        });
+    }
+    static getToken(alias) {
+        return this.tokens.get(alias) || null;
+    }
+    static getAllTokens() {
+        return new Map(this.tokens);
+    }
+    static hasToken(alias) {
+        return this.tokens.has(alias);
+    }
+    static removeToken(alias) {
+        return this.tokens.delete(alias);
+    }
+    static getTokenByValue(tokenValue) {
+        for (const [, config] of this.tokens) {
+            if (config.token === tokenValue) {
+                return config;
+            }
+        }
+        return null;
+    }
+    static validateTokenFormat(token) {
+        const tokenRegex = /^[a-f0-9]{32}$/i;
+        return tokenRegex.test(token);
+    }
+    static listTokenAliases() {
+        return Array.from(this.tokens.keys());
+    }
+    // --- Team Incoming Token Management ---
+    static getTeamToken(alias) {
+        return this.teamTokens.get(alias) || null;
+    }
+    static hasTeamToken(alias) {
+        return this.teamTokens.has(alias);
+    }
+    static listTeamTokenAliases() {
+        return Array.from(this.teamTokens.keys());
+    }
+    static getAllTeamTokens() {
+        return new Map(this.teamTokens);
+    }
+    // --- Outgoing Token Management ---
+    static getOutgoingToken(alias) {
+        return this.outgoingTokens.get(alias) || null;
+    }
+    static hasOutgoingToken(alias) {
+        return this.outgoingTokens.has(alias);
+    }
+    static listOutgoingTokenAliases() {
+        return Array.from(this.outgoingTokens.keys());
+    }
+}

package/dist/services/index.js

@@ -0,0 +1,4 @@
+export { BaseWebhookService } from './base/BaseWebhookService.js';
+export { IncomingWebhookService } from './IncomingWebhookService.js';
+export { TeamIncomingWebhookService } from './TeamIncomingWebhookService.js';
+export { ConfigService } from './configService.js';

package/dist/tools/GenerateWebhookScriptTool.js

@@ -0,0 +1,232 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+class GenerateWebhookScriptTool extends MCPTool {
+    name = "generate_webhook_script";
+    description = "Generate a script to send messages via Jandi webhooks. Supports both Incoming and Team Incoming webhook types in Python, Node.js, curl, and bash.";
+    schema = {
+        language: {
+            type: z.enum(['python', 'nodejs', 'curl', 'bash']),
+            description: "Programming language for the generated script",
+        },
+        webhookType: {
+            type: z.enum(['incoming', 'team-incoming']).optional(),
+            description: "Webhook type: 'incoming' (channel message) or 'team-incoming' (personal message). Default is 'incoming'",
+        },
+        token: {
+            type: z.string(),
+            description: "Jandi webhook token (32-character hexadecimal string)",
+        },
+        message: {
+            type: z.string(),
+            description: "The message content to send",
+        },
+        color: {
+            type: z.string().optional(),
+            description: "Hex color code for the message (e.g., '#FF0000')",
+        },
+        title: {
+            type: z.string().optional(),
+            description: "Title for the message attachment",
+        },
+        description: {
+            type: z.string().optional(),
+            description: "Description for the message attachment",
+        },
+        imageUrl: {
+            type: z.string().optional(),
+            description: "Image URL for the message attachment",
+        },
+        teamId: {
+            type: z.string().optional(),
+            description: "Jandi team ID (required for team-incoming webhook type)",
+        },
+        email: {
+            type: z.string().optional(),
+            description: "Comma-separated recipient emails (required for team-incoming webhook type)",
+        },
+    };
+    getBaseUrl(input) {
+        const type = input.webhookType || 'incoming';
+        if (type === 'team-incoming') {
+            return `https://wh.jandi.com/connect-api/team-webhook/${input.teamId}/${input.token}`;
+        }
+        return `https://wh.jandi.com/connect-api/webhook/${input.token}`;
+    }
+    buildPayload(input) {
+        const hasAttachment = input.color || input.title || input.description || input.imageUrl;
+        const data = { body: input.message };
+        if (input.webhookType === 'team-incoming' && input.email) {
+            data.to = input.email;
+        }
+        if (hasAttachment) {
+            if (input.color)
+                data.connectColor = input.color;
+            if (input.title || input.description || input.imageUrl) {
+                const info = {};
+                if (input.title)
+                    info.title = input.title;
+                if (input.description)
+                    info.description = input.description;
+                if (input.imageUrl)
+                    info.imageUrl = input.imageUrl;
+                data.connectInfo = [info];
+            }
+        }
+        return data;
+    }
+    generatePythonScript(input) {
+        const url = this.getBaseUrl(input);
+        const payload = this.buildPayload(input);
+        const payloadStr = JSON.stringify(payload, null, 8).replace(/^/gm, '    ').trim();
+        return `#!/usr/bin/env python3
+import requests
+import json
+
+def send_jandi_message():
+    url = "${url}"
+
+    headers = {
+        "Accept": "application/vnd.tosslab.jandi-v2+json",
+        "Content-Type": "application/json"
+    }
+
+    data = ${payloadStr}
+
+    try:
+        response = requests.post(url, headers=headers, data=json.dumps(data))
+        if response.status_code == 200:
+            print("Message sent successfully!")
+        else:
+            print(f"Error: {response.status_code} - {response.text}")
+    except Exception as e:
+        print(f"Error sending message: {e}")
+
+if __name__ == "__main__":
+    send_jandi_message()
+`;
+    }
+    generateNodejsScript(input) {
+        const url = this.getBaseUrl(input);
+        const payload = this.buildPayload(input);
+        const payloadStr = JSON.stringify(payload, null, 4);
+        return `const axios = require('axios');
+
+async function sendJandiMessage() {
+    const url = '${url}';
+
+    const headers = {
+        'Accept': 'application/vnd.tosslab.jandi-v2+json',
+        'Content-Type': 'application/json'
+    };
+
+    const data = ${payloadStr};
+
+    try {
+        const response = await axios.post(url, data, { headers });
+        console.log('Message sent successfully!');
+    } catch (error) {
+        console.error('Error sending message:', error.response?.data || error.message);
+    }
+}
+
+sendJandiMessage();
+`;
+    }
+    generateCurlScript(input) {
+        const url = this.getBaseUrl(input);
+        const payload = this.buildPayload(input);
+        const jsonData = JSON.stringify(payload);
+        return `#!/bin/bash
+curl -X POST "${url}" \\
+  -H "Accept: application/vnd.tosslab.jandi-v2+json" \\
+  -H "Content-Type: application/json" \\
+  -d '${jsonData}'
+`;
+    }
+    generateBashScript(input) {
+        const type = input.webhookType || 'incoming';
+        const payload = this.buildPayload(input);
+        const jsonData = JSON.stringify(payload).replace(/"/g, '\\"');
+        let urlSetup;
+        if (type === 'team-incoming') {
+            urlSetup = `TEAM_ID="${input.teamId}"
+TOKEN="${input.token}"
+URL="https://wh.jandi.com/connect-api/team-webhook/$TEAM_ID/$TOKEN"`;
+        }
+        else {
+            urlSetup = `TOKEN="${input.token}"
+URL="https://wh.jandi.com/connect-api/webhook/$TOKEN"`;
+        }
+        return `#!/bin/bash
+
+# Jandi ${type === 'team-incoming' ? 'Team Incoming' : 'Incoming'} Webhook Script
+${urlSetup}
+
+JSON_DATA="${jsonData}"
+
+# Send message
+curl -X POST "$URL" \\
+  -H "Accept: application/vnd.tosslab.jandi-v2+json" \\
+  -H "Content-Type: application/json" \\
+  -d "$JSON_DATA"
+`;
+    }
+    async execute(input) {
+        try {
+            const type = input.webhookType || 'incoming';
+            if (type === 'team-incoming') {
+                if (!input.teamId) {
+                    return { success: false, error: "teamId is required for team-incoming webhook type" };
+                }
+                if (!input.email) {
+                    return { success: false, error: "email is required for team-incoming webhook type" };
+                }
+            }
+            let script;
+            let fileExtension;
+            let executionInstructions;
+            switch (input.language) {
+                case 'python':
+                    script = this.generatePythonScript(input);
+                    fileExtension = '.py';
+                    executionInstructions = 'python3 script.py (requires: pip install requests)';
+                    break;
+                case 'nodejs':
+                    script = this.generateNodejsScript(input);
+                    fileExtension = '.js';
+                    executionInstructions = 'node script.js (requires: npm install axios)';
+                    break;
+                case 'curl':
+                    script = this.generateCurlScript(input);
+                    fileExtension = '.sh';
+                    executionInstructions = 'bash script.sh (requires: curl)';
+                    break;
+                case 'bash':
+                    script = this.generateBashScript(input);
+                    fileExtension = '.sh';
+                    executionInstructions = 'bash script.sh (requires: curl)';
+                    break;
+            }
+            return {
+                success: true,
+                data: {
+                    language: input.language,
+                    webhookType: type,
+                    fileExtension,
+                    executionInstructions,
+                    script,
+                    message: `Successfully generated ${input.language} script for Jandi ${type} webhook`,
+                    features: {
+                        hasColor: !!input.color,
+                        hasAttachment: !!(input.title || input.description || input.imageUrl),
+                        hasRecipients: !!input.email
+                    }
+                }
+            };
+        }
+        catch (error) {
+            return { success: false, error: `Error generating script: ${error}` };
+        }
+    }
+}
+export default GenerateWebhookScriptTool;

package/dist/tools/incoming/SendMessageTool.js

@@ -0,0 +1,48 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+import { IncomingWebhookService } from "../../services/IncomingWebhookService.js";
+import { resolveIncomingToken } from "../../utils/resolveToken.js";
+class SendMessageTool extends MCPTool {
+    name = "send_message";
+    description = "Send a basic text message to Jandi channel via Incoming Webhook";
+    schema = {
+        message: {
+            type: z.string(),
+            description: "The message text to send to Jandi",
+        },
+        token: {
+            type: z.string().optional(),
+            description: "Jandi webhook token (32-character hexadecimal string). If not provided, will use tokenAlias or default token",
+        },
+        tokenAlias: {
+            type: z.string().optional(),
+            description: "Token alias from configuration (e.g., 'default', 'dev', 'prod'). If not provided, will use 'default'",
+        },
+    };
+    async execute(input) {
+        try {
+            const resolved = resolveIncomingToken(input);
+            if (!resolved.success) {
+                return { success: false, error: resolved.error };
+            }
+            const message = IncomingWebhookService.createBasicMessage(input.message);
+            const result = await IncomingWebhookService.sendMessage(resolved.config, message);
+            if (result.success) {
+                return {
+                    success: true,
+                    data: {
+                        message: "Message sent successfully to Jandi",
+                        tokenUsed: resolved.config.alias || 'direct'
+                    }
+                };
+            }
+            else {
+                return { success: false, error: result.error };
+            }
+        }
+        catch (error) {
+            return { success: false, error: `Unexpected error: ${error}` };
+        }
+    }
+}
+export default SendMessageTool;