n8n-nodes-zalo-bot-stephen 0.1.0

package/README.md

@@ -0,0 +1,125 @@
+# n8n-nodes-zalo-bot
+
+Custom n8n nodes for integrating with Zalo Bot Platform.
+
+## Installation
+
+```bash
+npm install n8n-nodes-zalo-bot
+```
+
+Or install directly in n8n:
+
+1. Go to Settings > Community Nodes
+2. Click "Install a community node"
+3. Enter: `n8n-nodes-zalo-bot`
+4. Click "Install"
+
+## Nodes
+
+### Zalo Bot Trigger
+
+A webhook trigger node that starts your workflow when Zalo Bot receives a message.
+
+**Features:**
+- Automatically configures webhook URL when activated
+- Validates incoming webhook requests using secret token
+- Handles webhook lifecycle (add, check, remove)
+
+**Configuration:**
+1. Add your Zalo Bot API credentials
+2. The node will automatically set up the webhook when activated
+3. Incoming messages will trigger the workflow
+
+### Zalo Bot
+
+An action node for sending messages and interacting with Zalo Bot.
+
+**Resources:**
+- **Message**: Send text messages, photos, stickers, and chat actions
+- **Bot**: Get bot information
+- **Webhook**: Manage webhook configuration
+
+**Operations:**
+
+#### Message Operations
+- **Send Message**: Send a text message to a chat
+- **Send Photo**: Send a photo (supports URL or binary data)
+- **Send Sticker**: Send a sticker by sticker ID
+- **Send Chat Action**: Send typing indicators or upload status
+
+#### Bot Operations
+- **Get Me**: Get information about your bot
+
+#### Webhook Operations
+- **Get Webhook Info**: Get current webhook configuration
+- **Set Webhook**: Configure webhook URL manually
+- **Delete Webhook**: Remove webhook configuration
+
+## Credentials
+
+### Zalo Bot API
+
+1. Go to [Zalo Bot Platform](https://bot.zaloplatforms.com/)
+2. Create a bot and get your Bot Token
+3. Add the credential in n8n with your Bot Token
+
+## Usage Examples
+
+### Example 1: Simple Message Echo Bot
+
+1. Add **Zalo Bot Trigger** node
+2. Add **Zalo Bot** node
+3. Configure Zalo Bot node:
+   - Resource: Message
+   - Operation: Send Message
+   - Chat ID: `{{ $json.message.chat.id }}`
+   - Text: `{{ $json.message.text }}`
+
+### Example 2: Send Photo from URL
+
+1. Add **Zalo Bot** node
+2. Configure:
+   - Resource: Message
+   - Operation: Send Photo
+   - Chat ID: `123456789`
+   - Photo: `https://example.com/image.jpg`
+   - Caption: `Check out this image!`
+
+### Example 3: Send Photo from Binary Data
+
+1. Add a node that provides binary data (e.g., HTTP Request to download image)
+2. Add **Zalo Bot** node
+3. Configure:
+   - Resource: Message
+   - Operation: Send Photo
+   - Chat ID: `123456789`
+   - Binary Data: `true`
+   - Binary Property: `data` (or your binary property name)
+   - Caption: `Image from workflow`
+
+## API Reference
+
+For detailed API documentation, visit: [Zalo Bot Platform Docs](https://bot.zaloplatforms.com/docs/)
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Lint
+npm run lint
+```
+
+## License
+
+MIT
+
+## Support
+
+For issues and feature requests, please visit the [GitHub repository](https://github.com/your-username/n8n-nodes-zalo-bot).
+

package/dist/credentials/ZaloApi.credentials.d.ts

@@ -0,0 +1,8 @@
+import { ICredentialType, INodeProperties, ICredentialsDecrypted, INodeCredentialTestRequest, INodeCredentialTestResult } from 'n8n-workflow';
+export declare class ZaloApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    test(this: INodeCredentialTestRequest, credentials: ICredentialsDecrypted): Promise<INodeCredentialTestResult>;
+}

package/dist/credentials/ZaloApi.credentials.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZaloApi = void 0;
+class ZaloApi {
+    constructor() {
+        this.name = 'zaloApi';
+        this.displayName = 'Zalo Bot API';
+        this.documentationUrl = 'https://bot.zaloplatforms.com/docs/';
+        this.properties = [
+            {
+                displayName: 'Bot Token',
+                name: 'botToken',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'Your Zalo Bot API token',
+            },
+        ];
+    }
+    async test(credentials) {
+        const botToken = credentials.botToken;
+        if (!botToken) {
+            return {
+                status: 'Error',
+                message: 'Bot Token is required',
+            };
+        }
+        const options = {
+            url: `https://bot-api.zaloplatforms.com/bot${botToken}/getMe`,
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        };
+        try {
+            const response = await this.helpers.httpRequest(options);
+            if (response.ok) {
+                return {
+                    status: 'OK',
+                    message: 'Authentication successful',
+                };
+            }
+            else {
+                return {
+                    status: 'Error',
+                    message: response.description || 'Authentication failed',
+                };
+            }
+        }
+        catch (error) {
+            return {
+                status: 'Error',
+                message: error?.message || 'Failed to authenticate',
+            };
+        }
+    }
+}
+exports.ZaloApi = ZaloApi;

package/dist/gulpfile.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+declare function copyIcons(): NodeJS.ReadWriteStream;
+export declare const build: typeof copyIcons;
+export declare const buildIcons: typeof copyIcons;
+export {};

package/dist/gulpfile.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIcons = exports.build = void 0;
+const gulp_1 = require("gulp");
+function copyIcons() {
+    return (0, gulp_1.src)('icons/**/*').pipe((0, gulp_1.dest)('dist/icons'));
+}
+exports.build = copyIcons;
+exports.buildIcons = copyIcons;

package/dist/icons/zalo.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <rect width="100" height="100" rx="20" fill="#0068FF"/>
+  <path d="M30 35 L50 50 L70 35 M30 65 L50 50 L70 65" stroke="white" stroke-width="4" stroke-linecap="round" fill="none"/>
+  <circle cx="50" cy="50" r="25" fill="none" stroke="white" stroke-width="3"/>
+</svg>
+

package/dist/nodes/ZaloBot/ZaloBot.node.d.ts

@@ -0,0 +1,6 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class ZaloBot implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+    private makeRequestWithRetry;
+}

package/dist/nodes/ZaloBot/ZaloBot.node.js

@@ -0,0 +1,505 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZaloBot = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const form_data_1 = __importDefault(require("form-data"));
+class ZaloBot {
+    constructor() {
+        this.description = {
+            displayName: 'Zalo Bot',
+            name: 'zaloBot',
+            icon: 'file:zalo.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + "/" + $parameter["operation"]}}',
+            description: 'Send messages and interact with Zalo Bot',
+            defaults: {
+                name: 'Zalo Bot',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'zaloApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Message',
+                            value: 'message',
+                        },
+                        {
+                            name: 'Bot',
+                            value: 'bot',
+                        },
+                        {
+                            name: 'Webhook',
+                            value: 'webhook',
+                        },
+                    ],
+                    default: 'message',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Send Message',
+                            value: 'sendMessage',
+                            description: 'Send a text message',
+                            action: 'Send a text message',
+                        },
+                        {
+                            name: 'Send Photo',
+                            value: 'sendPhoto',
+                            description: 'Send a photo',
+                            action: 'Send a photo',
+                        },
+                        {
+                            name: 'Send Sticker',
+                            value: 'sendSticker',
+                            description: 'Send a sticker',
+                            action: 'Send a sticker',
+                        },
+                        {
+                            name: 'Send Chat Action',
+                            value: 'sendChatAction',
+                            description: 'Send a chat action (typing, uploading, etc.)',
+                            action: 'Send a chat action',
+                        },
+                    ],
+                    default: 'sendMessage',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['bot'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Get Me',
+                            value: 'getMe',
+                            description: 'Get bot information',
+                            action: 'Get bot information',
+                        },
+                    ],
+                    default: 'getMe',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['webhook'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Get Webhook Info',
+                            value: 'getWebhookInfo',
+                            description: 'Get webhook information',
+                            action: 'Get webhook information',
+                        },
+                        {
+                            name: 'Set Webhook',
+                            value: 'setWebhook',
+                            description: 'Set webhook URL',
+                            action: 'Set webhook URL',
+                        },
+                        {
+                            name: 'Delete Webhook',
+                            value: 'deleteWebhook',
+                            description: 'Delete webhook',
+                            action: 'Delete webhook',
+                        },
+                    ],
+                    default: 'getWebhookInfo',
+                },
+                {
+                    displayName: 'Chat ID',
+                    name: 'chatId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['sendMessage', 'sendPhoto', 'sendSticker', 'sendChatAction'],
+                        },
+                    },
+                    default: '',
+                    description: 'The chat ID to send the message to',
+                },
+                {
+                    displayName: 'Text',
+                    name: 'text',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['sendMessage'],
+                        },
+                    },
+                    default: '',
+                    description: 'The message text',
+                },
+                {
+                    displayName: 'Photo',
+                    name: 'photo',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['sendPhoto'],
+                        },
+                    },
+                    default: '',
+                    description: 'Photo URL or file_id. Leave empty to use binary data.',
+                },
+                {
+                    displayName: 'Binary Data',
+                    name: 'binaryData',
+                    type: 'boolean',
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['sendPhoto'],
+                        },
+                    },
+                    default: false,
+                    description: 'Whether to use binary data from previous node',
+                },
+                {
+                    displayName: 'Binary Property',
+                    name: 'binaryPropertyName',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['sendPhoto'],
+                            binaryData: [true],
+                        },
+                    },
+                    default: 'data',
+                    description: 'Name of the binary property containing the image',
+                },
+                {
+                    displayName: 'Caption',
+                    name: 'caption',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['sendPhoto'],
+                        },
+                    },
+                    default: '',
+                    description: 'Photo caption',
+                },
+                {
+                    displayName: 'Sticker ID',
+                    name: 'stickerId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['sendSticker'],
+                        },
+                    },
+                    default: '',
+                    description: 'The sticker ID to send',
+                },
+                {
+                    displayName: 'Action',
+                    name: 'action',
+                    type: 'options',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['sendChatAction'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Typing',
+                            value: 'typing',
+                        },
+                        {
+                            name: 'Upload Photo',
+                            value: 'upload_photo',
+                        },
+                        {
+                            name: 'Upload Video',
+                            value: 'upload_video',
+                        },
+                        {
+                            name: 'Upload Document',
+                            value: 'upload_document',
+                        },
+                        {
+                            name: 'Find Location',
+                            value: 'find_location',
+                        },
+                        {
+                            name: 'Record Video',
+                            value: 'record_video',
+                        },
+                        {
+                            name: 'Record Audio',
+                            value: 'record_audio',
+                        },
+                        {
+                            name: 'Upload Audio',
+                            value: 'upload_audio',
+                        },
+                    ],
+                    default: 'typing',
+                    description: 'The chat action to send',
+                },
+                {
+                    displayName: 'Webhook URL',
+                    name: 'webhookUrl',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['webhook'],
+                            operation: ['setWebhook'],
+                        },
+                    },
+                    default: '',
+                    description: 'The webhook URL to set',
+                },
+                {
+                    displayName: 'Secret Token',
+                    name: 'secretToken',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['webhook'],
+                            operation: ['setWebhook'],
+                        },
+                    },
+                    typeOptions: {
+                        password: true,
+                    },
+                    default: '',
+                    description: 'Secret token (8-256 characters) for webhook validation',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('zaloApi');
+        const botToken = credentials.botToken;
+        const baseUrl = `https://bot-api.zaloplatforms.com/bot${botToken}`;
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                let response;
+                if (resource === 'message') {
+                    if (operation === 'sendMessage') {
+                        const chatId = this.getNodeParameter('chatId', i);
+                        const text = this.getNodeParameter('text', i);
+                        const body = {
+                            chat_id: chatId,
+                            text,
+                        };
+                        response = await this.makeRequestWithRetry.call(this, `${baseUrl}/sendMessage`, 'POST', body);
+                    }
+                    else if (operation === 'sendPhoto') {
+                        const chatId = this.getNodeParameter('chatId', i);
+                        const useBinary = this.getNodeParameter('binaryData', i, false);
+                        const caption = this.getNodeParameter('caption', i, '');
+                        let photoData;
+                        let isMultipart = false;
+                        let filename = 'photo.jpg';
+                        let contentType = 'image/jpeg';
+                        if (useBinary) {
+                            const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i, 'data');
+                            const binaryData = this.helpers.assertBinaryData(i, binaryPropertyName);
+                            photoData = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
+                            // Get filename and contentType from binary data properties
+                            filename = binaryData.fileName || binaryData.file || 'photo.jpg';
+                            contentType = binaryData.mimeType || binaryData.mime || 'image/jpeg';
+                            isMultipart = true;
+                        }
+                        else {
+                            photoData = this.getNodeParameter('photo', i);
+                        }
+                        if (isMultipart) {
+                            const formData = new form_data_1.default();
+                            formData.append('chat_id', chatId);
+                            formData.append('photo', photoData, {
+                                filename: filename,
+                                contentType: contentType,
+                            });
+                            if (caption) {
+                                formData.append('caption', caption);
+                            }
+                            response = await this.makeRequestWithRetry.call(this, `${baseUrl}/sendPhoto`, 'POST', formData, true);
+                        }
+                        else {
+                            const body = {
+                                chat_id: chatId,
+                                photo: photoData,
+                            };
+                            if (caption) {
+                                body.caption = caption;
+                            }
+                            response = await this.makeRequestWithRetry.call(this, `${baseUrl}/sendPhoto`, 'POST', body);
+                        }
+                    }
+                    else if (operation === 'sendSticker') {
+                        const chatId = this.getNodeParameter('chatId', i);
+                        const stickerId = this.getNodeParameter('stickerId', i);
+                        const body = {
+                            chat_id: chatId,
+                            sticker_id: stickerId,
+                        };
+                        response = await this.makeRequestWithRetry.call(this, `${baseUrl}/sendSticker`, 'POST', body);
+                    }
+                    else if (operation === 'sendChatAction') {
+                        const chatId = this.getNodeParameter('chatId', i);
+                        const action = this.getNodeParameter('action', i);
+                        const body = {
+                            chat_id: chatId,
+                            action: action,
+                        };
+                        response = await this.makeRequestWithRetry.call(this, `${baseUrl}/sendChatAction`, 'POST', body);
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+                    }
+                }
+                else if (resource === 'bot') {
+                    if (operation === 'getMe') {
+                        response = await this.makeRequestWithRetry.call(this, `${baseUrl}/getMe`, 'GET');
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+                    }
+                }
+                else if (resource === 'webhook') {
+                    if (operation === 'getWebhookInfo') {
+                        response = await this.makeRequestWithRetry.call(this, `${baseUrl}/getWebhookInfo`, 'GET');
+                    }
+                    else if (operation === 'setWebhook') {
+                        const webhookUrl = this.getNodeParameter('webhookUrl', i);
+                        const secretToken = this.getNodeParameter('secretToken', i);
+                        const body = {
+                            url: webhookUrl,
+                            secret_token: secretToken,
+                        };
+                        response = await this.makeRequestWithRetry.call(this, `${baseUrl}/setWebhook`, 'POST', body);
+                    }
+                    else if (operation === 'deleteWebhook') {
+                        response = await this.makeRequestWithRetry.call(this, `${baseUrl}/deleteWebhook`, 'POST');
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+                    }
+                }
+                else {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown resource: ${resource}`);
+                }
+                if (!response.ok) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.description || 'API request failed', { code: response.error_code?.toString() });
+                }
+                returnData.push({
+                    json: response.result || response,
+                    pairedItem: {
+                        item: i,
+                    },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                        },
+                        pairedItem: {
+                            item: i,
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+    async makeRequestWithRetry(url, method, body, isMultipart = false, maxRetries = 3) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const options = {
+                    method,
+                    url,
+                    headers: {},
+                };
+                if (isMultipart && body instanceof form_data_1.default) {
+                    options.body = body;
+                    options.headers = body.getHeaders();
+                }
+                else if (body) {
+                    options.body = body;
+                    options.headers['Content-Type'] = 'application/json';
+                    options.json = true;
+                }
+                else {
+                    options.headers['Content-Type'] = 'application/json';
+                }
+                const response = await this.helpers.httpRequest(options);
+                return response;
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on client errors (4xx)
+                if (error.response?.status >= 400 && error.response?.status < 500) {
+                    throw error;
+                }
+                // Retry on network errors or server errors (5xx)
+                if (attempt < maxRetries) {
+                    // Exponential backoff: wait 1s, 2s, 4s
+                    await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt - 1) * 1000));
+                    continue;
+                }
+            }
+        }
+        throw lastError || new Error('Request failed after retries');
+    }
+}
+exports.ZaloBot = ZaloBot;

package/dist/nodes/ZaloBot/ZaloBotInterface.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Zalo Bot API Response Structure
+ */
+export interface ZaloApiResponse<T = any> {
+    ok: boolean;
+    result?: T;
+    error_code?: number;
+    description?: string;
+}
+/**
+ * Bot Information from getMe
+ */
+export interface ZaloBotInfo {
+    id: string;
+    is_bot: boolean;
+    first_name?: string;
+    last_name?: string;
+    username?: string;
+    can_join_groups?: boolean;
+    can_read_all_group_messages?: boolean;
+    supports_inline_queries?: boolean;
+}
+/**
+ * Webhook Information
+ */
+export interface ZaloWebhookInfo {
+    url?: string;
+    has_custom_certificate?: boolean;
+    pending_update_count?: number;
+    last_error_date?: number;
+    last_error_message?: string;
+    max_connections?: number;
+    allowed_updates?: string[];
+    updated_at?: number;
+}
+/**
+ * Message from Zalo
+ */
+export interface ZaloMessage {
+    message_id: number;
+    from?: {
+        id: number;
+        is_bot: boolean;
+        first_name?: string;
+        last_name?: string;
+        username?: string;
+    };
+    chat: {
+        id: number;
+        type: 'private' | 'group' | 'supergroup' | 'channel';
+        title?: string;
+        username?: string;
+        first_name?: string;
+        last_name?: string;
+    };
+    date: number;
+    text?: string;
+    location?: {
+        latitude: number;
+        longitude: number;
+    };
+    photo?: Array<{
+        file_id: string;
+        file_unique_id: string;
+        width: number;
+        height: number;
+        file_size?: number;
+    }>;
+    sticker?: {
+        file_id: string;
+        file_unique_id: string;
+        width: number;
+        height: number;
+        emoji?: string;
+        set_name?: string;
+        file_size?: number;
+    };
+    document?: {
+        file_id: string;
+        file_unique_id: string;
+        file_name?: string;
+        mime_type?: string;
+        file_size?: number;
+    };
+}
+/**
+ * Update from getUpdates or Webhook
+ */
+export interface ZaloUpdate {
+    update_id: number;
+    message?: ZaloMessage;
+    edited_message?: ZaloMessage;
+    channel_post?: ZaloMessage;
+    edited_channel_post?: ZaloMessage;
+}
+/**
+ * Request Interfaces for API Calls
+ */
+export interface SendMessageRequest {
+    chat_id: string | number;
+    text: string;
+    parse_mode?: 'HTML' | 'Markdown' | 'MarkdownV2';
+    disable_web_page_preview?: boolean;
+    disable_notification?: boolean;
+    reply_to_message_id?: number;
+}
+export interface SendPhotoRequest {
+    chat_id: string | number;
+    photo: string;
+    caption?: string;
+    parse_mode?: 'HTML' | 'Markdown' | 'MarkdownV2';
+    disable_notification?: boolean;
+    reply_to_message_id?: number;
+}
+export interface SendStickerRequest {
+    chat_id: string | number;
+    sticker_id: string;
+    disable_notification?: boolean;
+    reply_to_message_id?: number;
+}
+export interface SendChatActionRequest {
+    chat_id: string | number;
+    action: 'typing' | 'upload_photo' | 'upload_video' | 'upload_document' | 'find_location' | 'record_video' | 'record_audio' | 'upload_audio';
+}
+export interface SetWebhookRequest {
+    url: string;
+    secret_token: string;
+    allowed_updates?: string[];
+}

package/dist/nodes/ZaloBot/ZaloBotInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/ZaloBot/ZaloBotTrigger.node.d.ts

@@ -0,0 +1,12 @@
+import { IWebhookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+export declare class ZaloBotTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhookMethods: {
+        default: {
+            checkExists(this: IWebhookFunctions): Promise<boolean>;
+            create(this: IWebhookFunctions): Promise<boolean>;
+            delete(this: IWebhookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/ZaloBot/ZaloBotTrigger.node.js

@@ -0,0 +1,212 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZaloBotTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const crypto = __importStar(require("crypto"));
+class ZaloBotTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'Zalo Bot Trigger',
+            name: 'zaloBotTrigger',
+            icon: 'file:zalo.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["event"]}}',
+            description: 'Starts workflow when Zalo Bot receives a message',
+            defaults: {
+                name: 'Zalo Bot Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'zaloApi',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Webhook Path',
+                    name: 'webhookPath',
+                    type: 'string',
+                    default: 'default',
+                    required: true,
+                    description: 'The path to listen for webhooks',
+                },
+            ],
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const credentials = await this.getCredentials('zaloApi');
+                    const botToken = credentials.botToken;
+                    try {
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `https://bot-api.zaloplatforms.com/bot${botToken}/getWebhookInfo`,
+                            headers: {
+                                'Content-Type': 'application/json',
+                            },
+                        });
+                        if (response.ok && response.result?.url) {
+                            const webhookUrl = this.getNodeWebhookUrl('default');
+                            return response.result.url === webhookUrl;
+                        }
+                        return false;
+                    }
+                    catch (error) {
+                        return false;
+                    }
+                },
+                async create() {
+                    const credentials = await this.getCredentials('zaloApi');
+                    const botToken = credentials.botToken;
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    // Generate secret token (32-64 characters, alphanumeric + special chars)
+                    const secretToken = crypto
+                        .randomBytes(32)
+                        .toString('base64')
+                        .replace(/[^a-zA-Z0-9]/g, '')
+                        .substring(0, 48);
+                    // Store secret token in node state for validation
+                    const nodeState = this.getWorkflowStaticData('node');
+                    nodeState.secretToken = secretToken;
+                    const body = {
+                        url: webhookUrl,
+                        secret_token: secretToken,
+                    };
+                    try {
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `https://bot-api.zaloplatforms.com/bot${botToken}/setWebhook`,
+                            headers: {
+                                'Content-Type': 'application/json',
+                            },
+                            body,
+                            json: true,
+                        });
+                        if (!response.ok) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to set webhook: ${response.description || 'Unknown error'}`, { code: response.error_code?.toString() });
+                        }
+                        return true;
+                    }
+                    catch (error) {
+                        if (error instanceof n8n_workflow_1.NodeOperationError) {
+                            throw error;
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to set webhook: ${error.message || 'Unknown error'}`);
+                    }
+                },
+                async delete() {
+                    const credentials = await this.getCredentials('zaloApi');
+                    const botToken = credentials.botToken;
+                    try {
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `https://bot-api.zaloplatforms.com/bot${botToken}/deleteWebhook`,
+                            headers: {
+                                'Content-Type': 'application/json',
+                            },
+                        });
+                        if (!response.ok) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to delete webhook: ${response.description || 'Unknown error'}`, { code: response.error_code?.toString() });
+                        }
+                        // Clear secret token from node state
+                        const nodeState = this.getWorkflowStaticData('node');
+                        delete nodeState.secretToken;
+                        return true;
+                    }
+                    catch (error) {
+                        if (error instanceof n8n_workflow_1.NodeOperationError) {
+                            throw error;
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to delete webhook: ${error.message || 'Unknown error'}`);
+                    }
+                },
+            },
+        };
+    }
+    async webhook() {
+        const req = this.getRequestObject();
+        const headers = this.getHeaderData();
+        const body = this.getBodyData();
+        // Validate secret token from header
+        const nodeState = this.getWorkflowStaticData('node');
+        const expectedSecretToken = nodeState.secretToken;
+        if (expectedSecretToken) {
+            const receivedSecretToken = headers['x-bot-api-secret-token'];
+            if (!receivedSecretToken) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Missing secret token in webhook request', { httpCode: 401 });
+            }
+            // Use timing-safe comparison to prevent timing attacks
+            // Convert strings to Buffers for timingSafeEqual
+            const expectedBuffer = Buffer.from(expectedSecretToken, 'utf8');
+            const receivedBuffer = Buffer.from(receivedSecretToken, 'utf8');
+            // timingSafeEqual requires buffers of equal length
+            if (expectedBuffer.length !== receivedBuffer.length) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid secret token in webhook request', { httpCode: 401 });
+            }
+            if (!crypto.timingSafeEqual(expectedBuffer, receivedBuffer)) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid secret token in webhook request', { httpCode: 401 });
+            }
+        }
+        // Parse incoming update
+        let update;
+        if (typeof body === 'object' && body !== null) {
+            update = body;
+        }
+        else if (typeof body === 'string') {
+            try {
+                update = JSON.parse(body);
+            }
+            catch (error) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in webhook body', { httpCode: 400 });
+            }
+        }
+        else {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid webhook body format', { httpCode: 400 });
+        }
+        // Return the update data to trigger the workflow
+        return {
+            workflowData: [
+                [
+                    {
+                        json: update,
+                    },
+                ],
+            ],
+        };
+    }
+}
+exports.ZaloBotTrigger = ZaloBotTrigger;

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "n8n-nodes-zalo-bot-stephen",
+  "version": "0.1.0",
+  "description": "n8n custom node for Zalo Bot Platform integration",
+  "keywords": [
+    "n8n-community-node-package",
+    "zalo",
+    "bot",
+    "messaging"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/your-username/n8n-nodes-zalo-bot",
+  "author": {
+    "name": "Your Name",
+    "email": "your.email@example.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/n8n-nodes-zalo-bot.git"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "lint": "eslint nodes credentials --ext .ts",
+    "lintfix": "eslint nodes credentials --ext .ts --fix",
+    "prepublishOnly": "echo Skipping build for publish"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 2,
+    "nodes": [
+      "dist/nodes/ZaloBot/ZaloBot.node.js",
+      "dist/nodes/ZaloBot/ZaloBotTrigger.node.js"
+    ],
+    "credentials": [
+      "dist/credentials/ZaloApi.credentials.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/gulp": "^4.0.18",
+    "@types/node": "^25.0.3",
+    "@typescript-eslint/parser": "^5.45.0",
+    "eslint-plugin-n8n-nodes-base": "~1.11.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "typescript": "~5.3.0"
+  },
+  "dependencies": {
+    "form-data": "^4.0.0",
+    "n8n-workflow": "^2.0.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "^2.0.0"
+  }
+}