cowork-os 0.3.21

package/dist/electron/electron/gateway/channels/signal.js

@@ -0,0 +1,582 @@
+"use strict";
+/**
+ * Signal Channel Adapter
+ *
+ * Implements the ChannelAdapter interface for Signal messaging.
+ * Uses signal-cli under the hood for communication.
+ *
+ * Features:
+ * - End-to-end encrypted messaging
+ * - Message deduplication
+ * - Read receipts and typing indicators
+ * - Group messaging support
+ * - Attachment support
+ * - Reaction support
+ *
+ * Requirements:
+ * - signal-cli installed and configured
+ * - Phone number registered with Signal
+ */
+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.SignalAdapter = void 0;
+exports.createSignalAdapter = createSignalAdapter;
+const signal_client_1 = require("./signal-client");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class SignalAdapter {
+    constructor(config) {
+        this.type = 'signal';
+        this.client = null;
+        this._status = 'disconnected';
+        this.messageHandlers = [];
+        this.errorHandlers = [];
+        this.statusHandlers = [];
+        this.callbackQueryHandlers = [];
+        // Message deduplication
+        this.processedMessages = new Map();
+        this.DEDUP_CACHE_TTL = 60000; // 1 minute
+        this.DEDUP_CACHE_MAX_SIZE = 1000;
+        this.config = {
+            deduplicationEnabled: true,
+            sendReadReceipts: true,
+            sendTypingIndicators: true,
+            maxAttachmentMb: 100,
+            pollInterval: 1000,
+            trustMode: 'tofu',
+            ...config,
+        };
+        // Set up attachments directory
+        this.attachmentsDir = path.join(os.tmpdir(), 'cowork-signal-attachments');
+        if (!fs.existsSync(this.attachmentsDir)) {
+            fs.mkdirSync(this.attachmentsDir, { recursive: true });
+        }
+    }
+    get status() {
+        return this._status;
+    }
+    get botUsername() {
+        return this._botUsername;
+    }
+    /**
+     * Connect to Signal
+     */
+    async connect() {
+        if (this._status === 'connected' || this._status === 'connecting') {
+            return;
+        }
+        this.setStatus('connecting');
+        try {
+            // Create Signal client
+            this.client = new signal_client_1.SignalClient({
+                phoneNumber: this.config.phoneNumber,
+                cliPath: this.config.cliPath,
+                dataDir: this.config.dataDir,
+                mode: this.config.mode,
+                socketPath: this.config.socketPath,
+                verbose: process.env.NODE_ENV === 'development',
+            });
+            // Check installation
+            const installCheck = await this.client.checkInstallation();
+            if (!installCheck.installed) {
+                throw new Error(installCheck.error || 'signal-cli not installed');
+            }
+            console.log(`signal-cli version: ${installCheck.version}`);
+            // Check registration
+            const regCheck = await this.client.checkRegistration();
+            if (!regCheck.registered) {
+                throw new Error(regCheck.error || 'Phone number not registered');
+            }
+            // Set up event handlers
+            this.client.on('message', (message) => {
+                this.handleIncomingMessage(message);
+            });
+            this.client.on('error', (error) => {
+                this.handleError(error, 'client');
+            });
+            this.client.on('connected', () => {
+                console.log('Signal client connected');
+            });
+            this.client.on('disconnected', () => {
+                console.log('Signal client disconnected');
+                if (this._status === 'connected') {
+                    this.setStatus('disconnected');
+                }
+            });
+            // Start receiving messages
+            await this.client.startReceiving();
+            // Set bot username to phone number
+            this._botUsername = this.config.phoneNumber;
+            // Start deduplication cleanup
+            if (this.config.deduplicationEnabled) {
+                this.startDedupCleanup();
+            }
+            this.setStatus('connected');
+            console.log(`Signal adapter connected for ${this.config.phoneNumber}`);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.setStatus('error', err);
+            throw err;
+        }
+    }
+    /**
+     * Disconnect from Signal
+     */
+    async disconnect() {
+        // Stop dedup cleanup
+        if (this.dedupCleanupTimer) {
+            clearInterval(this.dedupCleanupTimer);
+            this.dedupCleanupTimer = undefined;
+        }
+        // Clear caches
+        this.processedMessages.clear();
+        // Stop client
+        if (this.client) {
+            await this.client.stopReceiving();
+            this.client = null;
+        }
+        this._botUsername = undefined;
+        this.setStatus('disconnected');
+    }
+    /**
+     * Send a message
+     */
+    async sendMessage(message) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Signal client is not connected');
+        }
+        // Prepare attachments
+        const attachmentPaths = [];
+        if (message.attachments) {
+            for (const attachment of message.attachments) {
+                const filePath = await this.prepareAttachment(attachment);
+                if (filePath) {
+                    attachmentPaths.push(filePath);
+                }
+            }
+        }
+        // Add response prefix if configured
+        let text = message.text;
+        if (this.config.responsePrefix) {
+            text = `${this.config.responsePrefix} ${text}`;
+        }
+        // Send the message
+        const result = await this.client.sendMessage(message.chatId, text, {
+            attachments: attachmentPaths.length > 0 ? attachmentPaths : undefined,
+            quote: message.replyTo ? {
+                timestamp: parseInt(message.replyTo, 10),
+                author: message.chatId,
+            } : undefined,
+        });
+        return result.timestamp.toString();
+    }
+    /**
+     * Prepare an attachment for sending
+     */
+    async prepareAttachment(attachment) {
+        if (attachment.url && fs.existsSync(attachment.url)) {
+            return attachment.url;
+        }
+        if (attachment.data) {
+            const fileName = attachment.fileName || `attachment_${Date.now()}`;
+            const filePath = path.join(this.attachmentsDir, fileName);
+            fs.writeFileSync(filePath, attachment.data);
+            return filePath;
+        }
+        return null;
+    }
+    /**
+     * Edit a message (not supported by Signal)
+     */
+    async editMessage(chatId, messageId, text) {
+        throw new Error('Signal does not support message editing');
+    }
+    /**
+     * Delete a message
+     */
+    async deleteMessage(chatId, messageId) {
+        // Signal supports remote delete but it's complex
+        // For now, just log a warning
+        console.warn('Signal message deletion not fully implemented');
+    }
+    /**
+     * Send a document/file
+     */
+    async sendDocument(chatId, filePath, caption) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Signal client is not connected');
+        }
+        const text = caption || path.basename(filePath);
+        const result = await this.client.sendMessage(chatId, text, {
+            attachments: [filePath],
+        });
+        return result.timestamp.toString();
+    }
+    /**
+     * Send a photo/image
+     */
+    async sendPhoto(chatId, filePath, caption) {
+        return this.sendDocument(chatId, filePath, caption);
+    }
+    /**
+     * Register a message handler
+     */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    /**
+     * Register a callback query handler (not supported by Signal)
+     */
+    onCallbackQuery(handler) {
+        this.callbackQueryHandlers.push(handler);
+    }
+    /**
+     * Answer callback query (not supported by Signal)
+     */
+    async answerCallbackQuery(queryId, text, showAlert) {
+        // Signal doesn't have inline keyboards
+        console.warn('Signal does not support callback queries');
+    }
+    /**
+     * Register an error handler
+     */
+    onError(handler) {
+        this.errorHandlers.push(handler);
+    }
+    /**
+     * Register a status change handler
+     */
+    onStatusChange(handler) {
+        this.statusHandlers.push(handler);
+    }
+    /**
+     * Get channel info
+     */
+    async getInfo() {
+        return {
+            type: 'signal',
+            status: this._status,
+            botId: this.config.phoneNumber,
+            botUsername: this.config.phoneNumber,
+            botDisplayName: `Signal (${this.config.phoneNumber})`,
+            extra: {
+                mode: this.config.mode,
+                trustMode: this.config.trustMode,
+            },
+        };
+    }
+    // ============================================================================
+    // Extended Features
+    // ============================================================================
+    /**
+     * Send typing indicator
+     */
+    async sendTyping(chatId) {
+        if (!this.client || !this.config.sendTypingIndicators) {
+            return;
+        }
+        try {
+            await this.client.sendTyping(chatId);
+        }
+        catch (error) {
+            // Ignore typing indicator errors
+        }
+    }
+    /**
+     * Stop typing indicator
+     */
+    async stopTyping(chatId) {
+        if (!this.client || !this.config.sendTypingIndicators) {
+            return;
+        }
+        try {
+            await this.client.sendTyping(chatId, true);
+        }
+        catch (error) {
+            // Ignore typing indicator errors
+        }
+    }
+    /**
+     * Add reaction to a message
+     */
+    async addReaction(chatId, messageId, emoji) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Signal client is not connected');
+        }
+        await this.client.sendReaction(chatId, emoji, chatId, // targetAuthor
+        parseInt(messageId, 10));
+    }
+    /**
+     * Remove reaction from a message
+     */
+    async removeReaction(chatId, messageId, emoji) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Signal client is not connected');
+        }
+        await this.client.sendReaction(chatId, emoji, chatId, // targetAuthor
+        parseInt(messageId, 10), true // remove
+        );
+    }
+    /**
+     * Send read receipt
+     */
+    async sendReadReceipt(sender, messageTimestamp) {
+        if (!this.client || !this.config.sendReadReceipts) {
+            return;
+        }
+        try {
+            await this.client.sendReadReceipt(sender, [messageTimestamp]);
+        }
+        catch (error) {
+            // Ignore read receipt errors
+        }
+    }
+    /**
+     * Get contacts
+     */
+    async getContacts() {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Signal client is not connected');
+        }
+        return this.client.getContacts();
+    }
+    /**
+     * Get groups
+     */
+    async getGroups() {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Signal client is not connected');
+        }
+        return this.client.getGroups();
+    }
+    /**
+     * Trust a contact's identity
+     */
+    async trustIdentity(phoneNumber) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Signal client is not connected');
+        }
+        await this.client.trustIdentity(phoneNumber, this.config.trustMode === 'always');
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    /**
+     * Handle incoming Signal message
+     */
+    async handleIncomingMessage(signalMessage) {
+        const envelope = signalMessage.envelope;
+        const dataMessage = envelope.dataMessage;
+        // Skip non-data messages
+        if (!dataMessage?.message) {
+            return;
+        }
+        // Generate message ID from timestamp
+        const messageId = envelope.timestamp.toString();
+        // Check for duplicates
+        if (this.config.deduplicationEnabled && this.isMessageProcessed(messageId)) {
+            console.log(`Skipping duplicate Signal message ${messageId}`);
+            return;
+        }
+        // Mark as processed
+        if (this.config.deduplicationEnabled) {
+            this.markMessageProcessed(messageId);
+        }
+        // Check access policy
+        if (!this.isAllowedSender(envelope.source)) {
+            console.log(`Ignoring message from unauthorized sender: ${envelope.source}`);
+            return;
+        }
+        // Convert to IncomingMessage
+        const message = {
+            messageId,
+            channel: 'signal',
+            userId: envelope.source,
+            userName: envelope.source, // Signal doesn't provide names in messages
+            chatId: dataMessage.groupInfo?.groupId || envelope.source,
+            text: dataMessage.message,
+            timestamp: new Date(envelope.timestamp),
+            replyTo: dataMessage.quote?.id?.toString(),
+            attachments: this.convertAttachments(dataMessage.attachments),
+            raw: signalMessage,
+        };
+        // Send read receipt
+        if (this.config.sendReadReceipts) {
+            await this.sendReadReceipt(envelope.source, envelope.timestamp);
+        }
+        // Notify handlers
+        for (const handler of this.messageHandlers) {
+            try {
+                await handler(message);
+            }
+            catch (error) {
+                console.error('Error in Signal message handler:', error);
+                this.handleError(error instanceof Error ? error : new Error(String(error)), 'messageHandler');
+            }
+        }
+    }
+    /**
+     * Convert Signal attachments to MessageAttachment format
+     */
+    convertAttachments(attachments) {
+        if (!attachments || attachments.length === 0) {
+            return undefined;
+        }
+        return attachments.map(att => {
+            let type = 'file';
+            if (att.contentType.startsWith('image/')) {
+                type = 'image';
+            }
+            else if (att.contentType.startsWith('audio/')) {
+                type = 'audio';
+            }
+            else if (att.contentType.startsWith('video/')) {
+                type = 'video';
+            }
+            return {
+                type,
+                url: att.localPath,
+                mimeType: att.contentType,
+                fileName: att.filename,
+                size: att.size,
+            };
+        });
+    }
+    /**
+     * Check if sender is allowed
+     */
+    isAllowedSender(sender) {
+        // Skip messages from self
+        if (sender === this.config.phoneNumber) {
+            return false;
+        }
+        // Check allowlist if configured
+        if (this.config.allowedNumbers && this.config.allowedNumbers.length > 0) {
+            // Normalize phone numbers for comparison
+            const normalizedSender = sender.replace(/[^+\d]/g, '');
+            return this.config.allowedNumbers.some(num => {
+                const normalizedNum = num.replace(/[^+\d]/g, '');
+                return normalizedSender === normalizedNum || normalizedSender.endsWith(normalizedNum);
+            });
+        }
+        // Check DM policy
+        switch (this.config.dmPolicy) {
+            case 'disabled':
+                return false;
+            case 'allowlist':
+                return false; // No allowlist configured
+            case 'pairing':
+                // TODO: Implement pairing code system
+                return true;
+            case 'open':
+            default:
+                return true;
+        }
+    }
+    /**
+     * Check if message was already processed
+     */
+    isMessageProcessed(messageId) {
+        return this.processedMessages.has(messageId);
+    }
+    /**
+     * Mark message as processed
+     */
+    markMessageProcessed(messageId) {
+        this.processedMessages.set(messageId, Date.now());
+        // Prevent unbounded growth
+        if (this.processedMessages.size > this.DEDUP_CACHE_MAX_SIZE) {
+            this.cleanupDedupCache();
+        }
+    }
+    /**
+     * Start periodic dedup cache cleanup
+     */
+    startDedupCleanup() {
+        this.dedupCleanupTimer = setInterval(() => {
+            this.cleanupDedupCache();
+        }, this.DEDUP_CACHE_TTL);
+    }
+    /**
+     * Clean up old entries from dedup cache
+     */
+    cleanupDedupCache() {
+        const now = Date.now();
+        for (const [messageId, timestamp] of this.processedMessages) {
+            if (now - timestamp > this.DEDUP_CACHE_TTL) {
+                this.processedMessages.delete(messageId);
+            }
+        }
+    }
+    /**
+     * Handle errors
+     */
+    handleError(error, context) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error, context);
+            }
+            catch (e) {
+                console.error('Error in error handler:', e);
+            }
+        }
+    }
+    /**
+     * Set status and notify handlers
+     */
+    setStatus(status, error) {
+        this._status = status;
+        for (const handler of this.statusHandlers) {
+            try {
+                handler(status, error);
+            }
+            catch (e) {
+                console.error('Error in status handler:', e);
+            }
+        }
+    }
+}
+exports.SignalAdapter = SignalAdapter;
+/**
+ * Create a Signal adapter from configuration
+ */
+function createSignalAdapter(config) {
+    if (!config.phoneNumber) {
+        throw new Error('Signal phone number is required');
+    }
+    return new SignalAdapter(config);
+}