cc-jandi 1.0.0

package/dist/tools/incoming/SendRichMessageTool.js

@@ -0,0 +1,74 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+import { IncomingWebhookService } from "../../services/IncomingWebhookService.js";
+import { resolveIncomingToken } from "../../utils/resolveToken.js";
+import { validateHexColor } from "../../utils/validateColor.js";
+import { JandiColors } from "../../types/common.js";
+class SendRichMessageTool extends MCPTool {
+    name = "send_rich_message";
+    description = "Send a rich message with color and attachments to Jandi channel via Incoming Webhook";
+    schema = {
+        message: {
+            type: z.string(),
+            description: "The main message text to send to Jandi",
+        },
+        color: {
+            type: z.string().optional(),
+            description: "Hex color code for the message attachment (e.g., '#FF0000' for red). Default is Jandi's default color",
+        },
+        connectInfo: {
+            type: z.array(z.object({
+                title: z.string().optional(),
+                description: z.string().optional(),
+                imageUrl: z.string().optional(),
+            })).optional(),
+            description: "Array of additional information sections with optional title, description, and image URL",
+        },
+        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 };
+            }
+            let normalizedColor = input.color;
+            if (input.color) {
+                const colorResult = validateHexColor(input.color);
+                if (!colorResult.valid) {
+                    return { success: false, error: colorResult.error };
+                }
+                normalizedColor = colorResult.normalized;
+            }
+            const message = IncomingWebhookService.createRichMessage(input.message, normalizedColor, input.connectInfo);
+            const result = await IncomingWebhookService.sendMessage(resolved.config, message);
+            if (result.success) {
+                return {
+                    success: true,
+                    data: {
+                        message: "Rich message sent successfully to Jandi",
+                        tokenUsed: resolved.config.alias || 'direct',
+                        messageDetails: {
+                            color: input.color || JandiColors.DEFAULT,
+                            attachments: input.connectInfo?.length || 0
+                        }
+                    }
+                };
+            }
+            else {
+                return { success: false, error: result.error };
+            }
+        }
+        catch (error) {
+            return { success: false, error: `Unexpected error: ${error}` };
+        }
+    }
+}
+export default SendRichMessageTool;

package/dist/tools/incoming/TestWebhookTool.js

@@ -0,0 +1,95 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+import { IncomingWebhookService } from "../../services/IncomingWebhookService.js";
+import { resolveIncomingToken } from "../../utils/resolveToken.js";
+import { JandiColors, MessageType } from "../../types/common.js";
+class TestWebhookTool extends MCPTool {
+    name = "test_webhook";
+    description = "Test Jandi Incoming Webhook connection by sending various test messages";
+    schema = {
+        token: {
+            type: z.string().optional(),
+            description: "Jandi webhook token to test (32-character hexadecimal string). If not provided, will use tokenAlias or default token",
+        },
+        tokenAlias: {
+            type: z.string().optional(),
+            description: "Token alias from configuration to test (e.g., 'default', 'dev', 'prod'). If not provided, will use 'default'",
+        },
+        testType: {
+            type: z.enum(['basic', 'rich', 'all']).optional(),
+            description: "Type of test to perform: 'basic' (simple message), 'rich' (rich message), 'all' (comprehensive test). Default is 'basic'",
+        },
+    };
+    async execute(input) {
+        try {
+            const resolved = resolveIncomingToken(input);
+            if (!resolved.success) {
+                return { success: false, error: resolved.error };
+            }
+            const config = resolved.config;
+            const testType = input.testType || 'basic';
+            const timestamp = new Date().toISOString();
+            const results = [];
+            if (testType === 'basic' || testType === 'all') {
+                const basicMessage = IncomingWebhookService.createBasicMessage(`🧪 Basic webhook test - ${timestamp}`);
+                const basicResult = await IncomingWebhookService.sendMessage(config, basicMessage);
+                results.push({
+                    type: 'basic',
+                    success: basicResult.success,
+                    error: basicResult.error
+                });
+            }
+            if (testType === 'rich' || testType === 'all') {
+                const richMessage = IncomingWebhookService.createRichMessage(`🎨 Rich webhook test - ${timestamp}`, JandiColors.BLUE, [{
+                        title: 'Test Section',
+                        description: 'This is a test of rich message functionality with color and attachments.',
+                    }]);
+                const richResult = await IncomingWebhookService.sendMessage(config, richMessage);
+                results.push({
+                    type: 'rich',
+                    success: richResult.success,
+                    error: richResult.error
+                });
+            }
+            if (testType === 'all') {
+                const statusTypes = [MessageType.SUCCESS, MessageType.WARNING, MessageType.ERROR];
+                for (const statusType of statusTypes) {
+                    const statusMessage = IncomingWebhookService.createStatusMessage(`${statusType.toUpperCase()} status test - ${timestamp}`, statusType, `This is a test of ${statusType} message type`);
+                    const statusResult = await IncomingWebhookService.sendMessage(config, statusMessage);
+                    results.push({
+                        type: `status_${statusType}`,
+                        success: statusResult.success,
+                        error: statusResult.error
+                    });
+                }
+            }
+            const successCount = results.filter(r => r.success).length;
+            const totalCount = results.length;
+            const allSuccessful = successCount === totalCount;
+            return {
+                success: allSuccessful,
+                data: {
+                    message: allSuccessful
+                        ? `All ${totalCount} webhook tests passed successfully`
+                        : `${successCount}/${totalCount} webhook tests passed`,
+                    tokenUsed: config.alias || 'direct',
+                    testType,
+                    timestamp,
+                    results,
+                    summary: {
+                        total: totalCount,
+                        successful: successCount,
+                        failed: totalCount - successCount
+                    }
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Unexpected error during webhook test: ${error}`
+            };
+        }
+    }
+}
+export default TestWebhookTool;

package/dist/tools/incoming/ValidateTokenTool.js

@@ -0,0 +1,54 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+import { IncomingWebhookService } from "../../services/IncomingWebhookService.js";
+import { resolveIncomingToken } from "../../utils/resolveToken.js";
+class ValidateTokenTool extends MCPTool {
+    name = "validate_token";
+    description = "Validate a Jandi Incoming Webhook token by sending a test message";
+    schema = {
+        token: {
+            type: z.string().optional(),
+            description: "Jandi webhook token to validate (32-character hexadecimal string). If not provided, will use tokenAlias or default token",
+        },
+        tokenAlias: {
+            type: z.string().optional(),
+            description: "Token alias from configuration to validate (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 result = await IncomingWebhookService.validateToken(resolved.config.token, resolved.config.url);
+            if (result.success) {
+                return {
+                    success: true,
+                    data: {
+                        message: "Token is valid and webhook is working",
+                        tokenAlias: resolved.config.alias || 'direct',
+                        tokenFormat: "valid"
+                    }
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    error: result.error,
+                    data: {
+                        tokenAlias: resolved.config.alias || 'direct',
+                        tokenFormat: "valid_format_but_failed"
+                    }
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Unexpected error during token validation: ${error}`
+            };
+        }
+    }
+}
+export default ValidateTokenTool;

package/dist/tools/outgoing/GenerateOutgoingHandlerTool.js

@@ -0,0 +1,217 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+class GenerateOutgoingHandlerTool extends MCPTool {
+    name = "generate_outgoing_handler";
+    description = "Generate a server handler for Jandi Outgoing Webhook. Creates ready-to-run code for receiving and responding to Jandi outgoing webhook events.";
+    schema = {
+        framework: {
+            type: z.enum(['express', 'fastapi', 'flask']),
+            description: "Server framework to generate the handler for: 'express' (Node.js), 'fastapi' (Python), 'flask' (Python)",
+        },
+        verificationToken: {
+            type: z.string().optional(),
+            description: "Verification token to validate incoming requests from Jandi. If provided, the handler will verify the token.",
+        },
+        handlerLogic: {
+            type: z.string().optional(),
+            description: "Custom handler logic description. Default generates an echo bot that responds with the received message.",
+        },
+    };
+    async execute(input) {
+        try {
+            let script;
+            let fileName;
+            let executionInstructions;
+            switch (input.framework) {
+                case 'express':
+                    script = this.generateExpressHandler(input);
+                    fileName = 'jandi-webhook-handler.js';
+                    executionInstructions = 'npm init -y && npm install express && node jandi-webhook-handler.js';
+                    break;
+                case 'fastapi':
+                    script = this.generateFastAPIHandler(input);
+                    fileName = 'jandi_webhook_handler.py';
+                    executionInstructions = 'pip install fastapi uvicorn && uvicorn jandi_webhook_handler:app --reload --port 3000';
+                    break;
+                case 'flask':
+                    script = this.generateFlaskHandler(input);
+                    fileName = 'jandi_webhook_handler.py';
+                    executionInstructions = 'pip install flask && python jandi_webhook_handler.py';
+                    break;
+            }
+            return {
+                success: true,
+                data: {
+                    framework: input.framework,
+                    fileName,
+                    executionInstructions,
+                    script,
+                    message: `Successfully generated ${input.framework} handler for Jandi Outgoing Webhook`,
+                    notes: [
+                        "The handler listens on port 3000 by default",
+                        "Use simulate_outgoing_payload to generate test payloads",
+                        "Response format: { body, connectColor?, connectInfo? }",
+                        "Response body max 5000 chars, total response max 256KB"
+                    ]
+                }
+            };
+        }
+        catch (error) {
+            return { success: false, error: `Error generating handler: ${error}` };
+        }
+    }
+    generateExpressHandler(input) {
+        const tokenCheck = input.verificationToken
+            ? `
+  // Verify token
+  if (req.body.token !== '${input.verificationToken}') {
+    return res.status(401).json({ error: 'Invalid token' });
+  }
+`
+            : '';
+        return `const express = require('express');
+const app = express();
+const PORT = 3000;
+
+app.use(express.json());
+
+// Jandi Outgoing Webhook Handler
+app.post('/webhook', (req, res) => {
+  const { token, teamName, roomName, writerName, writerEmail, text, keyword, createdAt } = req.body;
+  // Team Outgoing Webhook uses writer object: req.body.writer.name, req.body.writer.email
+${tokenCheck}
+  console.log(\`[\${new Date().toISOString()}] Message from \${writerName || req.body.writer?.name}: \${text}\`);
+
+  // Respond with a Jandi message format
+  // Return empty 200 to acknowledge without sending a response message
+  res.json({
+    body: \`Received: \${text}\`,
+    connectColor: "#FAC11B",
+    connectInfo: [{
+      title: "Webhook Response",
+      description: \`Processed message from \${writerName || req.body.writer?.name} in \${roomName}\`
+    }]
+  });
+});
+
+app.listen(PORT, () => {
+  console.log(\`Jandi Outgoing Webhook handler listening on port \${PORT}\`);
+  console.log(\`Endpoint: http://localhost:\${PORT}/webhook\`);
+});
+`;
+    }
+    generateFastAPIHandler(input) {
+        const tokenCheck = input.verificationToken
+            ? `
+    # Verify token
+    if payload.token != "${input.verificationToken}":
+        raise HTTPException(status_code=401, detail="Invalid token")
+`
+            : '';
+        return `from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+import uvicorn
+
+app = FastAPI(title="Jandi Outgoing Webhook Handler")
+
+
+class Writer(BaseModel):
+    id: Optional[str] = None
+    name: str
+    email: str
+    phoneNumber: Optional[str] = None
+
+
+class OutgoingPayload(BaseModel):
+    token: str
+    teamName: str
+    roomName: str
+    writerName: Optional[str] = None  # Standard Outgoing
+    writerEmail: Optional[str] = None  # Standard Outgoing
+    writer: Optional[Writer] = None  # Team Outgoing
+    text: str
+    keyword: str
+    createdAt: str
+    data: Optional[Dict[str, Any]] = None
+    platform: Optional[str] = None
+    ip: Optional[str] = None
+
+
+class ConnectInfo(BaseModel):
+    title: Optional[str] = None
+    description: Optional[str] = None
+    imageUrl: Optional[str] = None
+
+
+class WebhookResponse(BaseModel):
+    body: str
+    connectColor: Optional[str] = "#FAC11B"
+    connectInfo: Optional[List[ConnectInfo]] = None
+
+
+@app.post("/webhook", response_model=WebhookResponse)
+async def handle_webhook(payload: OutgoingPayload):
+${tokenCheck}
+    writer_name = payload.writerName or (payload.writer.name if payload.writer else "Unknown")
+    print(f"[{datetime.now().isoformat()}] Message from {writer_name}: {payload.text}")
+
+    return WebhookResponse(
+        body=f"Received: {payload.text}",
+        connectColor="#FAC11B",
+        connectInfo=[ConnectInfo(
+            title="Webhook Response",
+            description=f"Processed message from {writer_name} in {payload.roomName}"
+        )]
+    )
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=3000)
+`;
+    }
+    generateFlaskHandler(input) {
+        const tokenCheck = input.verificationToken
+            ? `
+    # Verify token
+    if data.get('token') != '${input.verificationToken}':
+        return jsonify({'error': 'Invalid token'}), 401
+`
+            : '';
+        return `from flask import Flask, request, jsonify
+from datetime import datetime
+
+app = Flask(__name__)
+
+
+@app.route('/webhook', methods=['POST'])
+def handle_webhook():
+    data = request.get_json()
+${tokenCheck}
+    # Support both standard and team outgoing webhook formats
+    writer_name = data.get('writerName') or data.get('writer', {}).get('name', 'Unknown')
+    text = data.get('text', '')
+    room_name = data.get('roomName', '')
+
+    print(f"[{datetime.now().isoformat()}] Message from {writer_name}: {text}")
+
+    # Respond with Jandi message format
+    return jsonify({
+        'body': f'Received: {text}',
+        'connectColor': '#FAC11B',
+        'connectInfo': [{
+            'title': 'Webhook Response',
+            'description': f'Processed message from {writer_name} in {room_name}'
+        }]
+    })
+
+
+if __name__ == '__main__':
+    print('Jandi Outgoing Webhook handler listening on port 3000')
+    print('Endpoint: http://localhost:3000/webhook')
+    app.run(host='0.0.0.0', port=3000, debug=True)
+`;
+    }
+}
+export default GenerateOutgoingHandlerTool;

package/dist/tools/outgoing/SimulateOutgoingPayloadTool.js

@@ -0,0 +1,103 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+class SimulateOutgoingPayloadTool extends MCPTool {
+    name = "simulate_outgoing_payload";
+    description = "Generate a simulated Jandi Outgoing Webhook payload JSON for testing your webhook handler server. Useful for local development and testing.";
+    schema = {
+        webhookType: {
+            type: z.enum(['outgoing', 'team-outgoing']).optional(),
+            description: "Type of outgoing webhook: 'outgoing' (standard) or 'team-outgoing' (team). Default is 'outgoing'",
+        },
+        text: {
+            type: z.string(),
+            description: "The message text that triggered the webhook",
+        },
+        keyword: {
+            type: z.string().optional(),
+            description: "The keyword that triggered the outgoing webhook. Default is 'test'",
+        },
+        teamName: {
+            type: z.string().optional(),
+            description: "Team name for the payload. Default is 'TestTeam'",
+        },
+        roomName: {
+            type: z.string().optional(),
+            description: "Chat room name for the payload. Default is 'TestRoom'",
+        },
+        writerName: {
+            type: z.string().optional(),
+            description: "Writer name for the payload. Default is 'TestUser'",
+        },
+        writerEmail: {
+            type: z.string().optional(),
+            description: "Writer email for the payload. Default is 'test@example.com'",
+        },
+    };
+    async execute(input) {
+        try {
+            const webhookType = input.webhookType || 'outgoing';
+            const now = new Date().toISOString();
+            if (webhookType === 'team-outgoing') {
+                const payload = {
+                    token: "abcdef0123456789abcdef0123456789",
+                    teamName: input.teamName || "TestTeam",
+                    roomName: input.roomName || "TestRoom",
+                    writer: {
+                        id: "12345",
+                        name: input.writerName || "TestUser",
+                        email: input.writerEmail || "test@example.com",
+                        phoneNumber: "+82-10-1234-5678"
+                    },
+                    text: input.text,
+                    keyword: input.keyword || "test",
+                    createdAt: now,
+                    data: {},
+                    platform: "web",
+                    ip: "127.0.0.1"
+                };
+                return {
+                    success: true,
+                    data: {
+                        webhookType: 'team-outgoing',
+                        payload,
+                        payloadJson: JSON.stringify(payload, null, 2),
+                        curlCommand: this.generateCurlCommand(payload),
+                        message: "Team Outgoing Webhook test payload generated. Use curlCommand to test your handler."
+                    }
+                };
+            }
+            const payload = {
+                token: "abcdef0123456789abcdef0123456789",
+                teamName: input.teamName || "TestTeam",
+                roomName: input.roomName || "TestRoom",
+                writerName: input.writerName || "TestUser",
+                writerEmail: input.writerEmail || "test@example.com",
+                text: input.text,
+                keyword: input.keyword || "test",
+                createdAt: now,
+                data: {},
+                platform: "web",
+                ip: "127.0.0.1"
+            };
+            return {
+                success: true,
+                data: {
+                    webhookType: 'outgoing',
+                    payload,
+                    payloadJson: JSON.stringify(payload, null, 2),
+                    curlCommand: this.generateCurlCommand(payload),
+                    message: "Outgoing Webhook test payload generated. Use curlCommand to test your handler."
+                }
+            };
+        }
+        catch (error) {
+            return { success: false, error: `Error generating payload: ${error}` };
+        }
+    }
+    generateCurlCommand(payload) {
+        return `curl -X POST http://localhost:3000/webhook \\
+  -H "Content-Type: application/json" \\
+  -d '${JSON.stringify(payload)}'`;
+    }
+}
+export default SimulateOutgoingPayloadTool;

package/dist/tools/outgoing/ValidateOutgoingResponseTool.js

@@ -0,0 +1,96 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+import { validateHexColor } from "../../utils/validateColor.js";
+class ValidateOutgoingResponseTool extends MCPTool {
+    name = "validate_outgoing_response";
+    description = "Validate a Jandi Outgoing Webhook response format. Checks body length, color format, connectInfo structure, and total size limits.";
+    schema = {
+        body: {
+            type: z.string(),
+            description: "The response body text to validate",
+        },
+        connectColor: {
+            type: z.string().optional(),
+            description: "Hex color code to validate (e.g., '#FF0000')",
+        },
+        connectInfo: {
+            type: z.array(z.object({
+                title: z.string().optional(),
+                description: z.string().optional(),
+                imageUrl: z.string().optional(),
+            })).optional(),
+            description: "Array of connectInfo sections to validate",
+        },
+    };
+    async execute(input) {
+        const MAX_BODY_LENGTH = 5000;
+        const MAX_DATA_SIZE = 256 * 1024;
+        const issues = [];
+        const warnings = [];
+        // Validate body
+        if (!input.body || input.body.trim().length === 0) {
+            issues.push("body is required and cannot be empty");
+        }
+        else if (input.body.length > MAX_BODY_LENGTH) {
+            issues.push(`body exceeds maximum length of ${MAX_BODY_LENGTH} characters (current: ${input.body.length})`);
+        }
+        // Validate color format
+        if (input.connectColor) {
+            const colorResult = validateHexColor(input.connectColor);
+            if (!colorResult.valid) {
+                issues.push(`connectColor: ${colorResult.error}`);
+            }
+        }
+        // Validate connectInfo
+        if (input.connectInfo) {
+            if (!Array.isArray(input.connectInfo)) {
+                issues.push("connectInfo must be an array");
+            }
+            else {
+                input.connectInfo.forEach((info, index) => {
+                    if (!info.title && !info.description && !info.imageUrl) {
+                        warnings.push(`connectInfo[${index}] has no title, description, or imageUrl - it will be empty`);
+                    }
+                    if (info.imageUrl && !info.imageUrl.match(/^https?:\/\/.+/)) {
+                        issues.push(`connectInfo[${index}].imageUrl must be a valid HTTP/HTTPS URL`);
+                    }
+                });
+            }
+        }
+        // Validate total data size
+        const response = {
+            body: input.body,
+            connectColor: input.connectColor,
+            connectInfo: input.connectInfo
+        };
+        const dataSize = JSON.stringify(response).length;
+        if (dataSize > MAX_DATA_SIZE) {
+            issues.push(`Total response data exceeds maximum size of ${MAX_DATA_SIZE} bytes (current: ${dataSize})`);
+        }
+        const isValid = issues.length === 0;
+        return {
+            success: true,
+            data: {
+                valid: isValid,
+                message: isValid
+                    ? "Outgoing webhook response format is valid"
+                    : "Outgoing webhook response has validation issues",
+                issues: issues.length > 0 ? issues : undefined,
+                warnings: warnings.length > 0 ? warnings : undefined,
+                stats: {
+                    bodyLength: input.body?.length || 0,
+                    maxBodyLength: MAX_BODY_LENGTH,
+                    totalDataSize: dataSize,
+                    maxDataSize: MAX_DATA_SIZE,
+                    connectInfoSections: input.connectInfo?.length || 0
+                },
+                validResponseFormat: {
+                    body: "string (required, max 5000 chars)",
+                    connectColor: "string (optional, hex color e.g. '#FAC11B')",
+                    connectInfo: "array (optional, [{title?, description?, imageUrl?}])"
+                }
+            }
+        };
+    }
+}
+export default ValidateOutgoingResponseTool;