cowork-os 0.3.21

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

@@ -0,0 +1,432 @@
+"use strict";
+/**
+ * Matrix Client
+ *
+ * HTTP client for Matrix homeserver communication using the Client-Server API.
+ * Implements sync-based message receiving for real-time updates.
+ *
+ * Features:
+ * - Long-polling sync for real-time messages
+ * - Room message sending with formatting
+ * - File/media upload and download
+ * - Room state management
+ * - User presence
+ *
+ * Requirements:
+ * - Matrix homeserver URL (e.g., https://matrix.org)
+ * - Access token (from login or existing session)
+ * - User ID (e.g., @user:matrix.org)
+ */
+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.MatrixClient = void 0;
+const events_1 = require("events");
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Matrix Client
+ */
+class MatrixClient extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.syncing = false;
+        this.connected = false;
+        this.options = options;
+    }
+    /**
+     * Check if the homeserver is accessible and token is valid
+     */
+    async checkConnection() {
+        try {
+            const response = await this.apiRequest('GET', '/_matrix/client/v3/account/whoami');
+            return { success: true, userId: response.user_id };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Get user profile
+     */
+    async getUserProfile(userId) {
+        const targetUserId = userId || this.options.userId;
+        const profile = await this.apiRequest('GET', `/_matrix/client/v3/profile/${encodeURIComponent(targetUserId)}`);
+        return {
+            user_id: targetUserId,
+            displayname: profile.displayname,
+            avatar_url: profile.avatar_url,
+        };
+    }
+    /**
+     * Get joined rooms
+     */
+    async getJoinedRooms() {
+        const response = await this.apiRequest('GET', '/_matrix/client/v3/joined_rooms');
+        return response.joined_rooms;
+    }
+    /**
+     * Start syncing (receiving messages)
+     */
+    async startReceiving() {
+        if (this.syncing) {
+            return;
+        }
+        this.syncing = true;
+        this.connected = true;
+        this.emit('connected');
+        // Start sync loop
+        this.syncLoop();
+    }
+    /**
+     * Sync loop for receiving messages
+     */
+    async syncLoop() {
+        while (this.syncing) {
+            try {
+                const params = new URLSearchParams({
+                    timeout: '30000',
+                    ...(this.syncToken && { since: this.syncToken }),
+                    filter: JSON.stringify({
+                        room: {
+                            timeline: { limit: 50 },
+                            state: { lazy_load_members: true },
+                        },
+                        presence: { limit: 0 },
+                    }),
+                });
+                const response = await this.apiRequest('GET', `/_matrix/client/v3/sync?${params.toString()}`, undefined, 35000 // Slightly longer timeout than the sync timeout
+                );
+                this.syncToken = response.next_batch;
+                // Process room events
+                if (response.rooms?.join) {
+                    for (const [roomId, roomData] of Object.entries(response.rooms.join)) {
+                        // Check if we're filtering to specific rooms
+                        if (this.options.roomIds && this.options.roomIds.length > 0) {
+                            if (!this.options.roomIds.includes(roomId)) {
+                                continue;
+                            }
+                        }
+                        // Process timeline events (new messages)
+                        if (roomData.timeline?.events) {
+                            for (const event of roomData.timeline.events) {
+                                // Skip own messages
+                                if (event.sender === this.options.userId) {
+                                    continue;
+                                }
+                                // Only process m.room.message events
+                                if (event.type === 'm.room.message') {
+                                    this.emit('message', { ...event, room_id: roomId });
+                                }
+                            }
+                        }
+                    }
+                }
+                // Process invites
+                if (response.rooms?.invite) {
+                    for (const [roomId, inviteData] of Object.entries(response.rooms.invite)) {
+                        const inviter = inviteData.invite_state?.events?.find((e) => e.type === 'm.room.member' && e.content.membership === 'invite')?.sender;
+                        if (inviter) {
+                            this.emit('invite', roomId, inviter);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                if (this.syncing) {
+                    if (this.options.verbose) {
+                        console.error('Matrix sync error:', error);
+                    }
+                    this.emit('error', error instanceof Error ? error : new Error(String(error)));
+                    // Wait before retrying
+                    await new Promise((resolve) => setTimeout(resolve, 5000));
+                }
+            }
+        }
+    }
+    /**
+     * Stop syncing
+     */
+    async stopReceiving() {
+        this.syncing = false;
+        this.connected = false;
+        this.emit('disconnected');
+    }
+    /**
+     * Send a message to a room
+     */
+    async sendMessage(roomId, body, options) {
+        const content = {
+            msgtype: options?.msgtype || 'm.text',
+            body,
+        };
+        // Add formatted content if provided
+        if (options?.formattedBody) {
+            content.format = options.format || 'org.matrix.custom.html';
+            content.formatted_body = options.formattedBody;
+        }
+        // Add reply relationship if provided
+        if (options?.replyTo) {
+            content['m.relates_to'] = {
+                'm.in_reply_to': {
+                    event_id: options.replyTo,
+                },
+            };
+        }
+        const txnId = `m${Date.now()}${Math.random().toString(36).substring(2)}`;
+        const response = await this.apiRequest('PUT', `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`, content);
+        return response.event_id;
+    }
+    /**
+     * Send an image to a room
+     */
+    async sendImage(roomId, mxcUrl, body, info) {
+        const content = {
+            msgtype: 'm.image',
+            body,
+            url: mxcUrl,
+            info,
+        };
+        const txnId = `m${Date.now()}${Math.random().toString(36).substring(2)}`;
+        const response = await this.apiRequest('PUT', `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`, content);
+        return response.event_id;
+    }
+    /**
+     * Send a file to a room
+     */
+    async sendFile(roomId, mxcUrl, body, info) {
+        const content = {
+            msgtype: 'm.file',
+            body,
+            url: mxcUrl,
+            info,
+        };
+        const txnId = `m${Date.now()}${Math.random().toString(36).substring(2)}`;
+        const response = await this.apiRequest('PUT', `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`, content);
+        return response.event_id;
+    }
+    /**
+     * Upload media to the homeserver
+     */
+    async uploadMedia(filePath, contentType) {
+        const fileBuffer = fs.readFileSync(filePath);
+        const fileName = path.basename(filePath);
+        const mimeType = contentType || this.getMimeType(fileName);
+        return new Promise((resolve, reject) => {
+            const url = new URL(this.options.homeserver);
+            const isHttps = url.protocol === 'https:';
+            const httpModule = isHttps ? https : http;
+            const uploadPath = `/_matrix/media/v3/upload?filename=${encodeURIComponent(fileName)}`;
+            const req = httpModule.request({
+                hostname: url.hostname,
+                port: url.port || (isHttps ? 443 : 80),
+                path: uploadPath,
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.options.accessToken}`,
+                    'Content-Type': mimeType,
+                    'Content-Length': fileBuffer.length,
+                },
+            }, (res) => {
+                let data = '';
+                res.on('data', (chunk) => (data += chunk));
+                res.on('end', () => {
+                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(JSON.parse(data));
+                    }
+                    else {
+                        reject(new Error(`Upload failed: ${res.statusCode} ${data}`));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(fileBuffer);
+            req.end();
+        });
+    }
+    /**
+     * Get media download URL
+     */
+    getMediaUrl(mxcUrl) {
+        // Convert mxc://server/media_id to https://homeserver/_matrix/media/v3/download/server/media_id
+        const match = mxcUrl.match(/^mxc:\/\/([^/]+)\/(.+)$/);
+        if (!match) {
+            return mxcUrl;
+        }
+        return `${this.options.homeserver}/_matrix/media/v3/download/${match[1]}/${match[2]}`;
+    }
+    /**
+     * Redact (delete) a message
+     */
+    async redactMessage(roomId, eventId, reason) {
+        const txnId = `m${Date.now()}${Math.random().toString(36).substring(2)}`;
+        const response = await this.apiRequest('PUT', `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/redact/${encodeURIComponent(eventId)}/${txnId}`, reason ? { reason } : {});
+        return response.event_id;
+    }
+    /**
+     * Send a reaction to a message
+     */
+    async sendReaction(roomId, eventId, emoji) {
+        const content = {
+            'm.relates_to': {
+                rel_type: 'm.annotation',
+                event_id: eventId,
+                key: emoji,
+            },
+        };
+        const txnId = `m${Date.now()}${Math.random().toString(36).substring(2)}`;
+        const response = await this.apiRequest('PUT', `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/send/m.reaction/${txnId}`, content);
+        return response.event_id;
+    }
+    /**
+     * Send typing notification
+     */
+    async sendTyping(roomId, typing, timeout = 30000) {
+        await this.apiRequest('PUT', `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/typing/${encodeURIComponent(this.options.userId)}`, { typing, timeout: typing ? timeout : undefined });
+    }
+    /**
+     * Send read receipt
+     */
+    async sendReadReceipt(roomId, eventId) {
+        await this.apiRequest('POST', `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/receipt/m.read/${encodeURIComponent(eventId)}`, {});
+    }
+    /**
+     * Join a room
+     */
+    async joinRoom(roomIdOrAlias) {
+        const response = await this.apiRequest('POST', `/_matrix/client/v3/join/${encodeURIComponent(roomIdOrAlias)}`, {});
+        return response.room_id;
+    }
+    /**
+     * Leave a room
+     */
+    async leaveRoom(roomId) {
+        await this.apiRequest('POST', `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/leave`, {});
+    }
+    /**
+     * Make an API request
+     */
+    apiRequest(method, path, body, timeout = 30000) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(this.options.homeserver);
+            const isHttps = url.protocol === 'https:';
+            const httpModule = isHttps ? https : http;
+            const options = {
+                hostname: url.hostname,
+                port: url.port || (isHttps ? 443 : 80),
+                path,
+                method,
+                headers: {
+                    Authorization: `Bearer ${this.options.accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+                timeout,
+            };
+            const req = httpModule.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(data);
+                        }
+                    }
+                    else {
+                        let errorMessage = `HTTP ${res.statusCode}`;
+                        try {
+                            const errorData = JSON.parse(data);
+                            errorMessage = errorData.error || errorData.errcode || errorMessage;
+                        }
+                        catch {
+                            // Use status code as error
+                        }
+                        reject(new Error(errorMessage));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+            if (body) {
+                req.write(JSON.stringify(body));
+            }
+            req.end();
+        });
+    }
+    /**
+     * Get MIME type from filename
+     */
+    getMimeType(fileName) {
+        const ext = path.extname(fileName).toLowerCase();
+        const mimeTypes = {
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.webp': 'image/webp',
+            '.mp4': 'video/mp4',
+            '.webm': 'video/webm',
+            '.mp3': 'audio/mpeg',
+            '.ogg': 'audio/ogg',
+            '.wav': 'audio/wav',
+            '.pdf': 'application/pdf',
+            '.txt': 'text/plain',
+            '.json': 'application/json',
+        };
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Get user ID
+     */
+    getUserId() {
+        return this.options.userId;
+    }
+}
+exports.MatrixClient = MatrixClient;