cowork-os 0.3.21

package/dist/electron/electron/gateway/channels/line-client.js

@@ -0,0 +1,470 @@
+"use strict";
+/**
+ * LINE Messaging API Client
+ *
+ * HTTP-based client for LINE messaging communication.
+ * Uses webhooks for receiving and REST API for sending messages.
+ *
+ * Features:
+ * - Real-time message receiving via webhooks
+ * - Text, image, video, audio message support
+ * - Reply and push message support
+ * - User profile fetching
+ * - Group and room support
+ *
+ * Requirements:
+ * - LINE Channel Access Token (from LINE Developers Console)
+ * - LINE Channel Secret (for webhook signature verification)
+ * - Public webhook endpoint (use tunnel for development)
+ *
+ * Rate Limits:
+ * - Push messages: Varies by plan (free plan has limits)
+ * - Reply messages: Unlimited (use reply tokens when possible)
+ */
+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.LineClient = void 0;
+const events_1 = require("events");
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const crypto = __importStar(require("crypto"));
+/**
+ * LINE Messaging API Client
+ */
+class LineClient extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.connected = false;
+        this.userCache = new Map();
+        this.API_BASE = 'https://api.line.me/v2';
+        this.DATA_API_BASE = 'https://api-data.line.me/v2';
+        this.options = options;
+    }
+    /**
+     * Verify webhook signature
+     */
+    verifySignature(body, signature) {
+        const hash = crypto
+            .createHmac('sha256', this.options.channelSecret)
+            .update(body)
+            .digest('base64');
+        return hash === signature;
+    }
+    /**
+     * Check if credentials are valid by fetching bot info
+     */
+    async checkConnection() {
+        try {
+            const profile = await this.getBotInfo();
+            return { success: true, botId: profile.userId };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Get bot's own profile
+     */
+    async getBotInfo() {
+        const response = await this.apiRequest('GET', '/bot/info');
+        return {
+            userId: response.userId,
+            displayName: response.displayName,
+            pictureUrl: response.pictureUrl,
+        };
+    }
+    /**
+     * Start webhook server
+     */
+    async startReceiving() {
+        if (this.connected) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => {
+                this.handleWebhook(req, res);
+            });
+            this.server.on('error', (error) => {
+                let enhancedError = error;
+                // Provide better error messages for common issues
+                if (error.code === 'EADDRINUSE') {
+                    enhancedError = new Error(`Port ${this.options.webhookPort} is already in use. ` +
+                        `Another application or LINE channel may be using this port. ` +
+                        `Try a different webhook port in settings.`);
+                    enhancedError.code = 'EADDRINUSE';
+                }
+                else if (error.code === 'EACCES') {
+                    enhancedError = new Error(`Permission denied to use port ${this.options.webhookPort}. ` +
+                        `Try a port number above 1024.`);
+                    enhancedError.code = 'EACCES';
+                }
+                if (this.options.verbose) {
+                    console.error('LINE webhook server error:', enhancedError);
+                }
+                this.emit('error', enhancedError);
+                if (!this.connected) {
+                    reject(enhancedError);
+                }
+            });
+            this.server.listen(this.options.webhookPort, () => {
+                this.connected = true;
+                if (this.options.verbose) {
+                    console.log(`LINE webhook server listening on port ${this.options.webhookPort}${this.options.webhookPath}`);
+                }
+                this.emit('connected');
+                resolve();
+            });
+        });
+    }
+    /**
+     * Handle incoming webhook request
+     */
+    handleWebhook(req, res) {
+        // Only handle POST requests to webhook path
+        if (req.method !== 'POST' || req.url !== this.options.webhookPath) {
+            res.writeHead(404);
+            res.end();
+            return;
+        }
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString();
+        });
+        req.on('end', async () => {
+            try {
+                // Verify signature
+                const signature = req.headers['x-line-signature'];
+                if (!signature || !this.verifySignature(body, signature)) {
+                    if (this.options.verbose) {
+                        console.warn('LINE webhook: Invalid signature');
+                    }
+                    res.writeHead(401);
+                    res.end();
+                    return;
+                }
+                // Parse and process events
+                const data = JSON.parse(body);
+                if (data.events && Array.isArray(data.events)) {
+                    for (const event of data.events) {
+                        await this.processEvent(event);
+                    }
+                }
+                res.writeHead(200);
+                res.end();
+            }
+            catch (error) {
+                console.error('LINE webhook processing error:', error);
+                res.writeHead(500);
+                res.end();
+            }
+        });
+    }
+    /**
+     * Process a LINE webhook event
+     */
+    async processEvent(event) {
+        const eventType = event.type;
+        switch (eventType) {
+            case 'message':
+                await this.handleMessageEvent(event);
+                break;
+            case 'follow':
+                this.emit('follow', event.source && event.source.userId, event.replyToken);
+                break;
+            case 'unfollow':
+                this.emit('unfollow', event.source && event.source.userId);
+                break;
+            case 'join':
+                {
+                    const source = event.source;
+                    const groupOrRoomId = source.groupId || source.roomId;
+                    this.emit('join', groupOrRoomId, event.replyToken);
+                }
+                break;
+            case 'leave':
+                {
+                    const source = event.source;
+                    const groupOrRoomId = source.groupId || source.roomId;
+                    this.emit('leave', groupOrRoomId);
+                }
+                break;
+            default:
+                if (this.options.verbose) {
+                    console.log(`LINE: Unhandled event type: ${eventType}`);
+                }
+        }
+    }
+    /**
+     * Handle message event
+     */
+    async handleMessageEvent(event) {
+        const messageData = event.message;
+        const source = event.source;
+        const message = {
+            id: messageData.id,
+            type: messageData.type,
+            source: {
+                type: source.type,
+                userId: source.userId,
+                groupId: source.groupId,
+                roomId: source.roomId,
+            },
+            replyToken: event.replyToken,
+            timestamp: new Date(event.timestamp),
+            raw: event,
+        };
+        // Add type-specific content
+        switch (messageData.type) {
+            case 'text':
+                message.text = messageData.text;
+                break;
+            case 'image':
+            case 'video':
+            case 'audio':
+            case 'file':
+                message.contentProvider = messageData.contentProvider;
+                break;
+            case 'sticker':
+                message.sticker = {
+                    packageId: messageData.packageId,
+                    stickerId: messageData.stickerId,
+                };
+                break;
+            case 'location':
+                message.location = {
+                    title: messageData.title,
+                    address: messageData.address,
+                    latitude: messageData.latitude,
+                    longitude: messageData.longitude,
+                };
+                break;
+        }
+        this.emit('message', message);
+    }
+    /**
+     * Stop webhook server
+     */
+    async stopReceiving() {
+        if (this.server) {
+            return new Promise((resolve) => {
+                this.server.close(() => {
+                    this.server = undefined;
+                    this.connected = false;
+                    this.emit('disconnected');
+                    resolve();
+                });
+            });
+        }
+        this.connected = false;
+    }
+    /**
+     * Send reply message (using reply token - faster, unlimited)
+     */
+    async replyMessage(replyToken, messages) {
+        await this.apiRequest('POST', '/bot/message/reply', {
+            replyToken,
+            messages,
+        });
+    }
+    /**
+     * Send push message (direct - uses quota)
+     */
+    async pushMessage(to, messages) {
+        await this.apiRequest('POST', '/bot/message/push', {
+            to,
+            messages,
+        });
+    }
+    /**
+     * Send text message (convenience method)
+     */
+    async sendTextMessage(to, text, replyToken) {
+        const messages = [{ type: 'text', text }];
+        if (replyToken) {
+            await this.replyMessage(replyToken, messages);
+        }
+        else {
+            await this.pushMessage(to, messages);
+        }
+    }
+    /**
+     * Get user profile
+     */
+    async getUserProfile(userId) {
+        // Check cache
+        const cached = this.userCache.get(userId);
+        if (cached) {
+            return cached;
+        }
+        const response = await this.apiRequest('GET', `/bot/profile/${userId}`);
+        const profile = {
+            userId: response.userId,
+            displayName: response.displayName,
+            pictureUrl: response.pictureUrl,
+            statusMessage: response.statusMessage,
+        };
+        // Cache the profile
+        this.userCache.set(userId, profile);
+        return profile;
+    }
+    /**
+     * Get group member profile
+     */
+    async getGroupMemberProfile(groupId, userId) {
+        const response = await this.apiRequest('GET', `/bot/group/${groupId}/member/${userId}`);
+        return {
+            userId: response.userId,
+            displayName: response.displayName,
+            pictureUrl: response.pictureUrl,
+        };
+    }
+    /**
+     * Get room member profile
+     */
+    async getRoomMemberProfile(roomId, userId) {
+        const response = await this.apiRequest('GET', `/bot/room/${roomId}/member/${userId}`);
+        return {
+            userId: response.userId,
+            displayName: response.displayName,
+            pictureUrl: response.pictureUrl,
+        };
+    }
+    /**
+     * Leave a group
+     */
+    async leaveGroup(groupId) {
+        await this.apiRequest('POST', `/bot/group/${groupId}/leave`);
+    }
+    /**
+     * Leave a room
+     */
+    async leaveRoom(roomId) {
+        await this.apiRequest('POST', `/bot/room/${roomId}/leave`);
+    }
+    /**
+     * Get message content (for images, videos, audio, files)
+     */
+    async getMessageContent(messageId) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(`${this.DATA_API_BASE}/bot/message/${messageId}/content`);
+            const req = https.request({
+                hostname: url.hostname,
+                path: url.pathname,
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${this.options.channelAccessToken}`,
+                },
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => {
+                    if (res.statusCode === 200) {
+                        resolve(Buffer.concat(chunks));
+                    }
+                    else {
+                        reject(new Error(`Failed to get content: ${res.statusCode}`));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.end();
+        });
+    }
+    /**
+     * Make API request
+     */
+    async apiRequest(method, path, body) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(`${this.API_BASE}${path}`);
+            const options = {
+                hostname: url.hostname,
+                path: url.pathname,
+                method,
+                headers: {
+                    Authorization: `Bearer ${this.options.channelAccessToken}`,
+                    'Content-Type': 'application/json',
+                },
+            };
+            const req = https.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                        try {
+                            resolve(data ? JSON.parse(data) : {});
+                        }
+                        catch {
+                            resolve({});
+                        }
+                    }
+                    else {
+                        let errorMessage = `LINE API error: ${res.statusCode}`;
+                        try {
+                            const errorData = JSON.parse(data);
+                            errorMessage = errorData.message || errorMessage;
+                        }
+                        catch {
+                            // Use default error message
+                        }
+                        reject(new Error(errorMessage));
+                    }
+                });
+            });
+            req.on('error', reject);
+            if (body) {
+                req.write(JSON.stringify(body));
+            }
+            req.end();
+        });
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Clear user cache
+     */
+    clearUserCache() {
+        this.userCache.clear();
+    }
+}
+exports.LineClient = LineClient;