clodds 1.1.0

package/dist/channels/line/index.js

@@ -0,0 +1,760 @@
+"use strict";
+/**
+ * Line Channel Module - LINE Messaging API integration
+ *
+ * Features:
+ * - LINE Bot messaging
+ * - Rich messages (flex, template)
+ * - Push/Reply messaging
+ * - Webhook handling
+ * - User/Group management
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineChannel = exports.ActionBuilder = exports.MessageBuilder = exports.LineClient = void 0;
+exports.createLineClient = createLineClient;
+exports.createLineChannel = createLineChannel;
+const events_1 = require("events");
+const http = __importStar(require("http"));
+const crypto_1 = require("crypto");
+const logger_1 = require("../../utils/logger");
+// =============================================================================
+// LINE CLIENT
+// =============================================================================
+class LineClient extends events_1.EventEmitter {
+    config;
+    baseUrl = 'https://api.line.me/v2';
+    dataUrl = 'https://api-data.line.me/v2';
+    webhookServer = null;
+    constructor(config) {
+        super();
+        this.config = {
+            webhookPort: 3000,
+            webhookPath: '/webhook',
+            ...config,
+        };
+    }
+    /** Make an API request */
+    async request(method, path, body, isDataApi = false) {
+        const baseUrl = isDataApi ? this.dataUrl : this.baseUrl;
+        const url = `${baseUrl}${path}`;
+        const options = {
+            method,
+            headers: {
+                'Authorization': `Bearer ${this.config.channelAccessToken}`,
+                'Content-Type': 'application/json',
+            },
+        };
+        if (body) {
+            options.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`LINE API error: ${response.status} - ${error}`);
+        }
+        if (response.status === 204) {
+            return {};
+        }
+        return response.json();
+    }
+    /** Verify webhook signature */
+    verifySignature(body, signature) {
+        const hash = (0, crypto_1.createHmac)('sha256', this.config.channelSecret)
+            .update(body)
+            .digest('base64');
+        return hash === signature;
+    }
+    /** Start webhook server */
+    startWebhook() {
+        return new Promise((resolve) => {
+            this.webhookServer = http.createServer((req, res) => {
+                if (req.method !== 'POST' || req.url !== this.config.webhookPath) {
+                    res.statusCode = 404;
+                    res.end();
+                    return;
+                }
+                let body = '';
+                req.on('data', chunk => { body += chunk; });
+                req.on('end', () => {
+                    const signature = req.headers['x-line-signature'];
+                    if (!this.verifySignature(body, signature)) {
+                        res.statusCode = 401;
+                        res.end('Invalid signature');
+                        return;
+                    }
+                    try {
+                        const data = JSON.parse(body);
+                        for (const event of data.events || []) {
+                            this.handleEvent(event);
+                        }
+                        res.statusCode = 200;
+                        res.end('OK');
+                    }
+                    catch (error) {
+                        logger_1.logger.error({ error }, 'Webhook error');
+                        res.statusCode = 500;
+                        res.end('Error');
+                    }
+                });
+            });
+            this.webhookServer.listen(this.config.webhookPort, () => {
+                logger_1.logger.info({ port: this.config.webhookPort, path: this.config.webhookPath }, 'LINE webhook server started');
+                resolve();
+            });
+        });
+    }
+    /** Stop webhook server */
+    stopWebhook() {
+        return new Promise((resolve) => {
+            if (this.webhookServer) {
+                this.webhookServer.close(() => {
+                    this.webhookServer = null;
+                    logger_1.logger.info('LINE webhook server stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /** Handle webhook event */
+    handleEvent(event) {
+        this.emit('event', event);
+        this.emit(event.type, event);
+        switch (event.type) {
+            case 'message':
+                this.emit(`message:${event.message?.type}`, event);
+                break;
+        }
+    }
+    /** Handle webhook payload from external server */
+    handleWebhookPayload(payload) {
+        if (!payload)
+            return;
+        if (Array.isArray(payload.events)) {
+            for (const event of payload.events || []) {
+                this.handleEvent(event);
+            }
+            return;
+        }
+        this.handleEvent(payload);
+    }
+    /** Reply to a message */
+    async reply(replyToken, messages) {
+        await this.request('POST', '/bot/message/reply', {
+            replyToken,
+            messages: messages.slice(0, 5), // Max 5 messages per reply
+        });
+    }
+    /** Reply with text */
+    async replyText(replyToken, text) {
+        await this.reply(replyToken, [{ type: 'text', text }]);
+    }
+    /** Push message to user/group/room */
+    async push(to, messages) {
+        await this.request('POST', '/bot/message/push', {
+            to,
+            messages: messages.slice(0, 5),
+        });
+    }
+    /** Push text message */
+    async pushText(to, text) {
+        await this.push(to, [{ type: 'text', text }]);
+    }
+    /** Multicast messages to multiple users */
+    async multicast(to, messages) {
+        await this.request('POST', '/bot/message/multicast', {
+            to: to.slice(0, 500), // Max 500 users
+            messages: messages.slice(0, 5),
+        });
+    }
+    /** Broadcast to all friends */
+    async broadcast(messages) {
+        await this.request('POST', '/bot/message/broadcast', {
+            messages: messages.slice(0, 5),
+        });
+    }
+    /** Get user profile */
+    async getProfile(userId) {
+        return this.request('GET', `/bot/profile/${userId}`);
+    }
+    /** Get group member profile */
+    async getGroupMemberProfile(groupId, userId) {
+        return this.request('GET', `/bot/group/${groupId}/member/${userId}`);
+    }
+    /** Get room member profile */
+    async getRoomMemberProfile(roomId, userId) {
+        return this.request('GET', `/bot/room/${roomId}/member/${userId}`);
+    }
+    /** Get group summary */
+    async getGroupSummary(groupId) {
+        return this.request('GET', `/bot/group/${groupId}/summary`);
+    }
+    /** Get group member count */
+    async getGroupMemberCount(groupId) {
+        const result = await this.request('GET', `/bot/group/${groupId}/members/count`);
+        return result.count;
+    }
+    /** Get room member count */
+    async getRoomMemberCount(roomId) {
+        const result = await this.request('GET', `/bot/room/${roomId}/members/count`);
+        return result.count;
+    }
+    /** Leave a group */
+    async leaveGroup(groupId) {
+        await this.request('POST', `/bot/group/${groupId}/leave`);
+    }
+    /** Leave a room */
+    async leaveRoom(roomId) {
+        await this.request('POST', `/bot/room/${roomId}/leave`);
+    }
+    /** Get message content (for images, videos, etc.) */
+    async getContent(messageId) {
+        const url = `${this.dataUrl}/bot/message/${messageId}/content`;
+        const response = await fetch(url, {
+            headers: {
+                'Authorization': `Bearer ${this.config.channelAccessToken}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get content: ${response.status}`);
+        }
+        return Buffer.from(await response.arrayBuffer());
+    }
+    /** Get rich menu */
+    async getRichMenu(richMenuId) {
+        return this.request('GET', `/bot/richmenu/${richMenuId}`);
+    }
+    /** Create rich menu */
+    async createRichMenu(richMenu) {
+        return this.request('POST', '/bot/richmenu', richMenu);
+    }
+    /** Delete rich menu */
+    async deleteRichMenu(richMenuId) {
+        await this.request('DELETE', `/bot/richmenu/${richMenuId}`);
+    }
+    /** Link rich menu to user */
+    async linkRichMenuToUser(userId, richMenuId) {
+        await this.request('POST', `/bot/user/${userId}/richmenu/${richMenuId}`);
+    }
+    /** Unlink rich menu from user */
+    async unlinkRichMenuFromUser(userId) {
+        await this.request('DELETE', `/bot/user/${userId}/richmenu`);
+    }
+    /** Set default rich menu */
+    async setDefaultRichMenu(richMenuId) {
+        await this.request('POST', `/bot/user/all/richmenu/${richMenuId}`);
+    }
+    /** Get number of sent messages */
+    async getMessageQuota() {
+        return this.request('GET', '/bot/message/quota');
+    }
+    /** Get bot info */
+    async getBotInfo() {
+        return this.request('GET', '/bot/info');
+    }
+}
+exports.LineClient = LineClient;
+// =============================================================================
+// MESSAGE BUILDERS
+// =============================================================================
+class MessageBuilder {
+    /** Create text message */
+    static text(text) {
+        return { type: 'text', text };
+    }
+    /** Create image message */
+    static image(originalUrl, previewUrl) {
+        return {
+            type: 'image',
+            originalContentUrl: originalUrl,
+            previewImageUrl: previewUrl || originalUrl,
+        };
+    }
+    /** Create video message */
+    static video(videoUrl, previewUrl) {
+        return {
+            type: 'video',
+            originalContentUrl: videoUrl,
+            previewImageUrl: previewUrl,
+        };
+    }
+    /** Create audio message */
+    static audio(audioUrl, duration) {
+        return {
+            type: 'audio',
+            originalContentUrl: audioUrl,
+            // duration is in milliseconds
+        };
+    }
+    /** Create location message */
+    static location(title, address, latitude, longitude) {
+        return {
+            type: 'location',
+            title,
+            address,
+            latitude,
+            longitude,
+        };
+    }
+    /** Create sticker message */
+    static sticker(packageId, stickerId) {
+        return {
+            type: 'sticker',
+            packageId,
+            stickerId,
+        };
+    }
+    /** Create button template */
+    static buttons(config) {
+        return {
+            type: 'template',
+            altText: config.title || config.text,
+            template: {
+                type: 'buttons',
+                title: config.title,
+                text: config.text,
+                thumbnailImageUrl: config.thumbnailImageUrl,
+                actions: config.actions.slice(0, 4), // Max 4 actions
+            },
+        };
+    }
+    /** Create confirm template */
+    static confirm(text, actions) {
+        return {
+            type: 'template',
+            altText: text,
+            template: {
+                type: 'confirm',
+                text,
+                actions,
+            },
+        };
+    }
+    /** Create carousel template */
+    static carousel(columns) {
+        return {
+            type: 'template',
+            altText: 'Carousel',
+            template: {
+                type: 'carousel',
+                columns: columns.slice(0, 10), // Max 10 columns
+            },
+        };
+    }
+    /** Create flex message */
+    static flex(altText, contents) {
+        return {
+            type: 'flex',
+            altText,
+            contents,
+        };
+    }
+    /** Create simple flex bubble */
+    static flexBubble(config) {
+        const contents = {
+            type: 'bubble',
+        };
+        if (config.header) {
+            contents.header = {
+                type: 'box',
+                layout: 'vertical',
+                contents: [{
+                        type: 'text',
+                        text: config.header,
+                    }],
+            };
+        }
+        contents.body = {
+            type: 'box',
+            layout: 'vertical',
+            contents: [{
+                    type: 'text',
+                    text: config.body,
+                }],
+        };
+        if (config.footer) {
+            contents.footer = {
+                type: 'box',
+                layout: 'vertical',
+                contents: [{
+                        type: 'button',
+                        text: config.footer,
+                        action: config.action,
+                    }],
+            };
+        }
+        return MessageBuilder.flex(config.body.slice(0, 100), contents);
+    }
+}
+exports.MessageBuilder = MessageBuilder;
+// =============================================================================
+// ACTION BUILDERS
+// =============================================================================
+class ActionBuilder {
+    /** Create message action */
+    static message(label, text) {
+        return { type: 'message', label, text };
+    }
+    /** Create URI action */
+    static uri(label, uri) {
+        return { type: 'uri', label, uri };
+    }
+    /** Create postback action */
+    static postback(label, data, displayText) {
+        return { type: 'postback', label, data, text: displayText };
+    }
+    /** Create datetime picker action */
+    static datetimePicker(label, data, mode) {
+        return { type: 'datetimepicker', label, data, mode };
+    }
+}
+exports.ActionBuilder = ActionBuilder;
+// =============================================================================
+// LINE CHANNEL ADAPTER
+// =============================================================================
+class LineChannel extends events_1.EventEmitter {
+    client;
+    isConnected = false;
+    config;
+    dmPolicy;
+    allowFrom;
+    groupAllowlist;
+    roomAllowlist;
+    callbacks;
+    pairing;
+    constructor(config, callbacks, pairing) {
+        super();
+        this.config = config;
+        this.client = new LineClient(config);
+        this.callbacks = callbacks;
+        this.pairing = pairing;
+        const policy = config.dmPolicy || 'pairing';
+        this.dmPolicy = policy;
+        this.allowFrom = new Set(config.allowFrom || []);
+        this.groupAllowlist = new Set(config.groupAllowlist || []);
+        this.roomAllowlist = new Set(config.roomAllowlist || []);
+        this.client.on('message:text', (event) => {
+            this.handleTextMessage(event).catch((error) => {
+                logger_1.logger.error({ error }, 'LINE message handler failed');
+            });
+        });
+        const mediaHandler = (event) => {
+            this.handleMediaMessage(event).catch((error) => {
+                logger_1.logger.error({ error }, 'LINE media handler failed');
+            });
+        };
+        this.client.on('message:image', mediaHandler);
+        this.client.on('message:video', mediaHandler);
+        this.client.on('message:audio', mediaHandler);
+        this.client.on('message:file', mediaHandler);
+        this.client.on('message:sticker', mediaHandler);
+        this.client.on('follow', (event) => {
+            this.emit('follow', { userId: event.source.userId, raw: event });
+        });
+        this.client.on('unfollow', (event) => {
+            this.emit('unfollow', { userId: event.source.userId, raw: event });
+        });
+        this.client.on('join', (event) => {
+            this.emit('join', {
+                groupId: event.source.groupId,
+                roomId: event.source.roomId,
+                raw: event,
+            });
+        });
+        this.client.on('leave', (event) => {
+            this.emit('leave', {
+                groupId: event.source.groupId,
+                roomId: event.source.roomId,
+                raw: event,
+            });
+        });
+        this.client.on('postback', (event) => {
+            this.emit('postback', {
+                data: event.postback?.data,
+                params: event.postback?.params,
+                userId: event.source.userId,
+                replyToken: event.replyToken,
+                raw: event,
+            });
+        });
+    }
+    /** Check if sender is allowed */
+    isAllowed(event) {
+        const userId = event.source.userId;
+        if (!userId)
+            return false;
+        // Group/room messages
+        if (event.source.groupId) {
+            if (this.groupAllowlist.size > 0) {
+                return this.groupAllowlist.has(event.source.groupId);
+            }
+            return true;
+        }
+        if (event.source.roomId) {
+            if (this.roomAllowlist.size > 0) {
+                return this.roomAllowlist.has(event.source.roomId);
+            }
+            return true;
+        }
+        // DM policy
+        if (this.dmPolicy === 'open') {
+            if (this.allowFrom.size === 0)
+                return true;
+            return this.allowFrom.has(userId) || this.allowFrom.has('*');
+        }
+        if (this.pairing) {
+            return this.pairing.isPaired('line', userId);
+        }
+        return false;
+    }
+    async handleTextMessage(event) {
+        if (!this.callbacks)
+            return;
+        if (!event.message?.text)
+            return;
+        if (!event.source.userId)
+            return;
+        if (!this.isAllowed(event)) {
+            if (this.dmPolicy === 'pairing' && this.pairing) {
+                const code = await this.pairing.createPairingRequest('line', event.source.userId);
+                if (code && event.replyToken) {
+                    await this.reply(event.replyToken, `Hi! I need to verify you first.\n\nYour pairing code is: **${code}**\n\nAsk an admin to approve it.`);
+                }
+            }
+            return;
+        }
+        const chatId = event.source.groupId || event.source.roomId || event.source.userId;
+        if (!chatId)
+            return;
+        const chatType = event.source.groupId || event.source.roomId ? 'group' : 'dm';
+        if (chatType === 'group') {
+            const requireMention = this.config.groups?.[chatId]?.requireMention ?? false;
+            if (requireMention) {
+                // LINE doesn't expose mentions in webhook events; skip when required.
+                return;
+            }
+        }
+        const message = {
+            id: event.message.id,
+            platform: 'line',
+            userId: event.source.userId,
+            chatId,
+            chatType,
+            text: event.message.text,
+            timestamp: new Date(event.timestamp),
+        };
+        await this.callbacks.onMessage(message);
+    }
+    async handleMediaMessage(event) {
+        if (!this.callbacks)
+            return;
+        if (!event.message?.id)
+            return;
+        if (!event.source.userId)
+            return;
+        if (!this.isAllowed(event)) {
+            if (this.dmPolicy === 'pairing' && this.pairing) {
+                const code = await this.pairing.createPairingRequest('line', event.source.userId);
+                if (code && event.replyToken) {
+                    await this.reply(event.replyToken, `Hi! I need to verify you first.\n\nYour pairing code is: **${code}**\n\nAsk an admin to approve it.`);
+                }
+            }
+            return;
+        }
+        const chatId = event.source.groupId || event.source.roomId || event.source.userId;
+        if (!chatId)
+            return;
+        const chatType = event.source.groupId || event.source.roomId ? 'group' : 'dm';
+        let attachmentType = 'document';
+        if (event.message.type === 'image')
+            attachmentType = 'image';
+        if (event.message.type === 'video')
+            attachmentType = 'video';
+        if (event.message.type === 'audio')
+            attachmentType = 'audio';
+        if (event.message.type === 'sticker')
+            attachmentType = 'sticker';
+        let data;
+        try {
+            const buffer = await this.client.getContent(event.message.id);
+            data = buffer.toString('base64');
+        }
+        catch (error) {
+            logger_1.logger.warn({ error }, 'Failed to download LINE media content');
+        }
+        const message = {
+            id: event.message.id,
+            platform: 'line',
+            userId: event.source.userId,
+            chatId,
+            chatType,
+            text: event.message?.text || '',
+            attachments: [{
+                    type: attachmentType,
+                    data,
+                }],
+            timestamp: new Date(event.timestamp),
+        };
+        await this.callbacks.onMessage(message);
+    }
+    /** Connect (start webhook) */
+    async connect() {
+        await this.client.startWebhook();
+        this.isConnected = true;
+        this.emit('connected');
+        logger_1.logger.info('LINE channel connected');
+    }
+    /** Disconnect */
+    async disconnect() {
+        await this.client.stopWebhook();
+        this.isConnected = false;
+        this.emit('disconnected');
+        logger_1.logger.info('LINE channel disconnected');
+    }
+    /** Send message */
+    async send(to, message) {
+        const msg = typeof message === 'string' ? MessageBuilder.text(message) : message;
+        await this.client.push(to, [msg]);
+    }
+    /** Reply to message */
+    async reply(replyToken, message) {
+        const msg = typeof message === 'string' ? MessageBuilder.text(message) : message;
+        await this.client.reply(replyToken, [msg]);
+    }
+    /** Get underlying client */
+    getClient() {
+        return this.client;
+    }
+    /** Check if connected */
+    connected() {
+        return this.isConnected;
+    }
+    async sendOutgoing(message) {
+        const target = message.chatId;
+        if (!target)
+            return;
+        const replyToken = message.thread?.threadId || message.thread?.replyToMessageId;
+        if (replyToken) {
+            await this.reply(replyToken, message.text);
+            return;
+        }
+        const attachments = message.attachments || [];
+        if (attachments.length > 0) {
+            if (message.text) {
+                await this.send(target, message.text);
+            }
+            for (const attachment of attachments) {
+                if (!attachment.url) {
+                    logger_1.logger.warn({ attachment }, 'LINE attachment missing public URL');
+                    continue;
+                }
+                switch (attachment.type) {
+                    case 'image':
+                        await this.send(target, MessageBuilder.image(attachment.url, attachment.url));
+                        break;
+                    case 'video':
+                        await this.send(target, MessageBuilder.video(attachment.url, attachment.url));
+                        break;
+                    case 'audio':
+                    case 'voice':
+                        await this.send(target, MessageBuilder.audio(attachment.url, attachment.duration || 1));
+                        break;
+                    case 'document':
+                        await this.send(target, `${attachment.filename || 'file'}: ${attachment.url}`);
+                        break;
+                    default:
+                        await this.send(target, `${attachment.filename || 'file'}: ${attachment.url}`);
+                        break;
+                }
+            }
+            return;
+        }
+        await this.send(target, message.text);
+    }
+}
+exports.LineChannel = LineChannel;
+// =============================================================================
+// FACTORY
+// =============================================================================
+function createLineClient(config) {
+    return new LineClient(config);
+}
+function createLineChannel(config, callbacks, pairing) {
+    const channel = new LineChannel(config, callbacks, pairing);
+    const useInternalWebhook = Boolean(config.useInternalWebhookServer || config.webhookPort || config.webhookPath);
+    return {
+        platform: 'line',
+        async start() {
+            if (useInternalWebhook) {
+                await channel.connect();
+            }
+            else {
+                logger_1.logger.info('LINE channel started (gateway webhook mode)');
+            }
+        },
+        async stop() {
+            if (useInternalWebhook) {
+                await channel.disconnect();
+            }
+        },
+        async sendMessage(message) {
+            await channel.sendOutgoing(message);
+            return null;
+        },
+        async editMessage(message) {
+            logger_1.logger.warn({ chatId: message.chatId, messageId: message.messageId }, 'LINE does not support message editing');
+        },
+        async deleteMessage(message) {
+            logger_1.logger.warn({ chatId: message.chatId, messageId: message.messageId }, 'LINE does not support message deletion');
+        },
+        async handleEvent(event, req) {
+            // Optional signature verification if raw body + signature are provided
+            const rawBody = req?.rawBody;
+            const signature = req?.headers?.['x-line-signature'];
+            if (rawBody && typeof signature === 'string') {
+                const ok = channel.getClient().verifySignature(rawBody, signature);
+                if (!ok) {
+                    throw new Error('Invalid LINE signature');
+                }
+            }
+            channel.getClient().handleWebhookPayload(event);
+            return null;
+        },
+    };
+}
+//# sourceMappingURL=index.js.map