cowork-os 0.3.21

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

@@ -0,0 +1,479 @@
+"use strict";
+/**
+ * BlueBubbles Client
+ *
+ * REST API client for BlueBubbles iMessage server.
+ * BlueBubbles runs on a Mac and exposes iMessage functionality via API.
+ *
+ * Features:
+ * - Send and receive iMessage/SMS
+ * - Attachment support (images, files)
+ * - Group chat support
+ * - Read receipts and typing indicators
+ * - Contact sync
+ *
+ * Requirements:
+ * - BlueBubbles server running on a Mac (https://bluebubbles.app/)
+ * - Server URL and password
+ * - Webhook endpoint for real-time notifications (optional)
+ *
+ * API Documentation:
+ * - https://docs.bluebubbles.app/server/guides/using-the-api
+ */
+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.BlueBubblesClient = void 0;
+const events_1 = require("events");
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+/**
+ * BlueBubbles REST API Client
+ */
+class BlueBubblesClient extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.connected = false;
+        this.lastMessageDate = 0;
+        this.options = {
+            pollInterval: 5000,
+            webhookPort: 3101,
+            webhookPath: '/bluebubbles/webhook',
+            ...options,
+        };
+        // Remove trailing slash from server URL
+        this.options.serverUrl = this.options.serverUrl.replace(/\/$/, '');
+    }
+    /**
+     * Check if server is reachable and password is correct
+     */
+    async checkConnection() {
+        try {
+            const response = await this.apiRequest('GET', '/server/info');
+            const data = response.data;
+            return {
+                success: true,
+                serverVersion: data?.os_version || data?.server_version,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Start receiving messages (via webhooks or polling)
+     */
+    async startReceiving() {
+        if (this.connected) {
+            return;
+        }
+        // Check connection first
+        const check = await this.checkConnection();
+        if (!check.success) {
+            throw new Error(check.error || 'Failed to connect to BlueBubbles server');
+        }
+        // Initialize last message date
+        this.lastMessageDate = Date.now();
+        // Try to start webhook server
+        if (this.options.webhookPort) {
+            try {
+                await this.startWebhookServer();
+                this.connected = true;
+                this.emit('connected');
+                return;
+            }
+            catch (error) {
+                if (this.options.verbose) {
+                    console.warn('BlueBubbles webhook server failed, falling back to polling:', error);
+                }
+            }
+        }
+        // Fall back to polling
+        this.startPolling();
+        this.connected = true;
+        this.emit('connected');
+    }
+    /**
+     * Start webhook server for real-time notifications
+     */
+    async startWebhookServer() {
+        return new Promise((resolve, reject) => {
+            this.webhookServer = http.createServer((req, res) => {
+                this.handleWebhook(req, res);
+            });
+            this.webhookServer.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 BlueBubbles 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('BlueBubbles webhook server error:', enhancedError);
+                }
+                reject(enhancedError);
+            });
+            this.webhookServer.listen(this.options.webhookPort, () => {
+                if (this.options.verbose) {
+                    console.log(`BlueBubbles webhook server listening on port ${this.options.webhookPort}${this.options.webhookPath}`);
+                }
+                resolve();
+            });
+        });
+    }
+    /**
+     * Handle webhook notification
+     */
+    handleWebhook(req, res) {
+        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', () => {
+            try {
+                const data = JSON.parse(body);
+                this.processWebhookEvent(data);
+                res.writeHead(200);
+                res.end();
+            }
+            catch (error) {
+                console.error('BlueBubbles webhook error:', error);
+                res.writeHead(500);
+                res.end();
+            }
+        });
+    }
+    /**
+     * Process webhook event
+     */
+    processWebhookEvent(data) {
+        const type = data.type;
+        switch (type) {
+            case 'new-message':
+                {
+                    const message = data.data;
+                    if (message && !message.isFromMe) {
+                        this.emit('message', this.normalizeMessage(message));
+                    }
+                }
+                break;
+            case 'updated-message':
+                {
+                    const message = data.data;
+                    if (message) {
+                        this.emit('messageUpdated', this.normalizeMessage(message));
+                    }
+                }
+                break;
+            case 'typing-indicator':
+                // Could emit typing event
+                break;
+            default:
+                if (this.options.verbose) {
+                    console.log(`BlueBubbles: Unhandled webhook type: ${type}`);
+                }
+        }
+    }
+    /**
+     * Start polling for new messages
+     */
+    startPolling() {
+        if (this.pollTimer) {
+            return;
+        }
+        this.pollTimer = setInterval(async () => {
+            try {
+                await this.pollMessages();
+            }
+            catch (error) {
+                if (this.options.verbose) {
+                    console.error('BlueBubbles poll error:', error);
+                }
+            }
+        }, this.options.pollInterval);
+        if (this.options.verbose) {
+            console.log(`BlueBubbles polling started (interval: ${this.options.pollInterval}ms)`);
+        }
+    }
+    /**
+     * Poll for new messages
+     */
+    async pollMessages() {
+        const response = await this.apiRequest('POST', '/message/query', {
+            with: ['chat', 'handle'],
+            sort: 'DESC',
+            after: this.lastMessageDate,
+            limit: 50,
+        });
+        const messages = (response.data || []);
+        // Process messages in chronological order
+        for (const msg of messages.reverse()) {
+            if (!msg.isFromMe && msg.dateCreated > this.lastMessageDate) {
+                this.emit('message', this.normalizeMessage(msg));
+                this.lastMessageDate = Math.max(this.lastMessageDate, msg.dateCreated);
+            }
+        }
+    }
+    /**
+     * Normalize message data
+     */
+    normalizeMessage(msg) {
+        return {
+            ...msg,
+            raw: msg,
+        };
+    }
+    /**
+     * Stop receiving messages
+     */
+    async stopReceiving() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = undefined;
+        }
+        if (this.webhookServer) {
+            return new Promise((resolve) => {
+                this.webhookServer.close(() => {
+                    this.webhookServer = undefined;
+                    this.connected = false;
+                    this.emit('disconnected');
+                    resolve();
+                });
+            });
+        }
+        this.connected = false;
+        this.emit('disconnected');
+    }
+    /**
+     * Send a message
+     */
+    async sendMessage(chatGuid, message, options) {
+        const response = await this.apiRequest('POST', '/message/text', {
+            chatGuid,
+            message,
+            subject: options?.subject,
+            method: options?.method || 'private-api',
+        });
+        return response.data;
+    }
+    /**
+     * Send a message to a new chat (by address)
+     */
+    async sendMessageToAddress(address, message, service = 'iMessage') {
+        // First, get or create chat
+        const chatResponse = await this.apiRequest('POST', '/chat/new', {
+            addresses: [address],
+            service,
+        });
+        const chat = chatResponse.data;
+        if (!chat || !chat.guid) {
+            throw new Error('Failed to create chat');
+        }
+        // Then send message
+        return this.sendMessage(chat.guid, message);
+    }
+    /**
+     * Get chats
+     */
+    async getChats(options) {
+        const response = await this.apiRequest('POST', '/chat/query', {
+            with: ['lastMessage', 'participants'],
+            sort: 'lastmessage',
+            limit: options?.limit || 25,
+            offset: options?.offset || 0,
+        });
+        return (response.data || []);
+    }
+    /**
+     * Get chat by GUID
+     */
+    async getChat(chatGuid) {
+        const response = await this.apiRequest('GET', `/chat/${encodeURIComponent(chatGuid)}`, {
+            with: ['participants', 'lastMessage'],
+        });
+        return response.data;
+    }
+    /**
+     * Get messages from a chat
+     */
+    async getMessages(chatGuid, options) {
+        const response = await this.apiRequest('GET', `/chat/${encodeURIComponent(chatGuid)}/message`, {
+            with: ['handle', 'attachment'],
+            sort: 'DESC',
+            limit: options?.limit || 25,
+            offset: options?.offset || 0,
+            after: options?.after,
+            before: options?.before,
+        });
+        return (response.data || []);
+    }
+    /**
+     * Mark chat as read
+     */
+    async markChatRead(chatGuid) {
+        await this.apiRequest('POST', `/chat/${encodeURIComponent(chatGuid)}/read`);
+    }
+    /**
+     * Send typing indicator
+     */
+    async sendTypingIndicator(chatGuid) {
+        await this.apiRequest('POST', `/chat/${encodeURIComponent(chatGuid)}/typing`);
+    }
+    /**
+     * Get attachment data
+     */
+    async getAttachment(attachmentGuid) {
+        return this.apiRequestBinary('GET', `/attachment/${encodeURIComponent(attachmentGuid)}/download`);
+    }
+    /**
+     * Make API request
+     */
+    async apiRequest(method, path, body) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(`${this.options.serverUrl}/api/v1${path}`);
+            // Add password to query params
+            url.searchParams.set('password', this.options.password);
+            // Add body params to query for GET requests
+            if (method === 'GET' && body) {
+                for (const [key, value] of Object.entries(body)) {
+                    if (value !== undefined) {
+                        url.searchParams.set(key, String(value));
+                    }
+                }
+            }
+            const isHttps = url.protocol === 'https:';
+            const requestModule = isHttps ? https : http;
+            const options = {
+                hostname: url.hostname,
+                port: url.port,
+                path: url.pathname + url.search,
+                method,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            };
+            const req = requestModule.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(JSON.parse(data));
+                        }
+                        catch {
+                            resolve({ data: data });
+                        }
+                    }
+                    else {
+                        let errorMessage = `BlueBubbles API error: ${res.statusCode}`;
+                        try {
+                            const errorData = JSON.parse(data);
+                            errorMessage = errorData.message || errorData.error || errorMessage;
+                        }
+                        catch {
+                            // Use default error message
+                        }
+                        reject(new Error(errorMessage));
+                    }
+                });
+            });
+            req.on('error', reject);
+            if (method !== 'GET' && body) {
+                req.write(JSON.stringify(body));
+            }
+            req.end();
+        });
+    }
+    /**
+     * Make binary API request (for attachments)
+     */
+    async apiRequestBinary(method, path) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(`${this.options.serverUrl}/api/v1${path}`);
+            url.searchParams.set('password', this.options.password);
+            const isHttps = url.protocol === 'https:';
+            const requestModule = isHttps ? https : http;
+            const options = {
+                hostname: url.hostname,
+                port: url.port,
+                path: url.pathname + url.search,
+                method,
+            };
+            const req = requestModule.request(options, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => {
+                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(Buffer.concat(chunks));
+                    }
+                    else {
+                        reject(new Error(`BlueBubbles API error: ${res.statusCode}`));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.end();
+        });
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Get server URL
+     */
+    getServerUrl() {
+        return this.options.serverUrl;
+    }
+}
+exports.BlueBubblesClient = BlueBubblesClient;