cowork-os 0.3.21

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

@@ -0,0 +1,500 @@
+"use strict";
+/**
+ * Signal Client
+ *
+ * Wrapper around signal-cli for sending and receiving Signal messages.
+ * Supports multiple modes:
+ * - Native: Direct CLI invocation (simplest, slower)
+ * - JSON-RPC: Socket-based communication (faster, requires daemon)
+ * - D-Bus: Linux D-Bus integration (Linux only)
+ *
+ * Requirements:
+ * - signal-cli installed (https://github.com/AsamK/signal-cli)
+ * - Phone number registered with Signal
+ *
+ * Installation:
+ *   brew install signal-cli (macOS)
+ *   apt install signal-cli (Ubuntu/Debian)
+ *   Or download from GitHub releases
+ */
+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.SignalClient = void 0;
+const child_process_1 = require("child_process");
+const events_1 = require("events");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const net = __importStar(require("net"));
+const readline = __importStar(require("readline"));
+/**
+ * Signal CLI Client
+ */
+class SignalClient extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.jsonRpcId = 0;
+        this.pendingRequests = new Map();
+        this.connected = false;
+        this.messageBuffer = '';
+        this.options = {
+            phoneNumber: options.phoneNumber,
+            cliPath: options.cliPath || 'signal-cli',
+            dataDir: options.dataDir || path.join(process.env.HOME || '', '.local', 'share', 'signal-cli'),
+            mode: options.mode || 'native',
+            socketPath: options.socketPath || '/tmp/signal-cli.socket',
+            verbose: options.verbose || false,
+        };
+    }
+    /**
+     * Check if signal-cli is installed and accessible
+     */
+    async checkInstallation() {
+        try {
+            const result = (0, child_process_1.execSync)(`${this.options.cliPath} --version`, {
+                encoding: 'utf-8',
+                timeout: 5000,
+            });
+            const version = result.trim().split('\n')[0];
+            return { installed: true, version };
+        }
+        catch (error) {
+            return {
+                installed: false,
+                error: `signal-cli not found at ${this.options.cliPath}. Install with: brew install signal-cli (macOS) or download from GitHub.`,
+            };
+        }
+    }
+    /**
+     * Check if the phone number is registered
+     */
+    async checkRegistration() {
+        try {
+            // Check accounts.json which maps phone numbers to account data paths
+            const accountsFile = path.join(this.options.dataDir, 'data', 'accounts.json');
+            if (!fs.existsSync(accountsFile)) {
+                return {
+                    registered: false,
+                    error: `Account not registered. Run: signal-cli -a ${this.options.phoneNumber} register`,
+                };
+            }
+            // Parse accounts.json and look for our phone number
+            const accountsData = JSON.parse(fs.readFileSync(accountsFile, 'utf-8'));
+            const account = accountsData.accounts?.find((acc) => acc.number === this.options.phoneNumber);
+            if (!account) {
+                return {
+                    registered: false,
+                    error: `Account not registered. Run: signal-cli -a ${this.options.phoneNumber} register`,
+                };
+            }
+            return { registered: true };
+        }
+        catch (error) {
+            return {
+                registered: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Start receiving messages
+     */
+    async startReceiving() {
+        if (this.connected) {
+            return;
+        }
+        if (this.options.mode === 'daemon') {
+            await this.startDaemonReceiving();
+        }
+        else {
+            await this.startNativeReceiving();
+        }
+    }
+    /**
+     * Start native mode receiving (spawns signal-cli receive)
+     */
+    async startNativeReceiving() {
+        const args = [
+            '-a', this.options.phoneNumber,
+            '--output', 'json',
+            'receive',
+            '--timeout', '-1', // Infinite timeout
+        ];
+        if (this.options.verbose) {
+            console.log(`Starting signal-cli: ${this.options.cliPath} ${args.join(' ')}`);
+        }
+        this.receiveProcess = (0, child_process_1.spawn)(this.options.cliPath, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        // Handle stdout (messages)
+        if (this.receiveProcess.stdout) {
+            const rl = readline.createInterface({
+                input: this.receiveProcess.stdout,
+                crlfDelay: Infinity,
+            });
+            rl.on('line', (line) => {
+                this.handleJsonLine(line);
+            });
+        }
+        // Handle stderr (errors/logs)
+        if (this.receiveProcess.stderr) {
+            this.receiveProcess.stderr.on('data', (data) => {
+                const message = data.toString().trim();
+                if (message && this.options.verbose) {
+                    console.log('[signal-cli]', message);
+                }
+            });
+        }
+        // Handle process exit
+        this.receiveProcess.on('exit', (code, signal) => {
+            this.connected = false;
+            this.emit('disconnected');
+            if (code !== 0 && code !== null) {
+                console.error(`signal-cli exited with code ${code}`);
+                // Attempt reconnection
+                this.scheduleReconnect();
+            }
+        });
+        this.receiveProcess.on('error', (error) => {
+            this.emit('error', error);
+        });
+        this.connected = true;
+        this.emit('connected');
+    }
+    /**
+     * Start JSON-RPC mode receiving
+     */
+    async startDaemonReceiving() {
+        return new Promise((resolve, reject) => {
+            this.jsonRpcSocket = net.createConnection(this.options.socketPath, () => {
+                this.connected = true;
+                this.emit('connected');
+                resolve();
+            });
+            this.jsonRpcSocket.on('data', (data) => {
+                this.messageBuffer += data.toString();
+                // Process complete JSON lines
+                let newlineIndex;
+                while ((newlineIndex = this.messageBuffer.indexOf('\n')) !== -1) {
+                    const line = this.messageBuffer.substring(0, newlineIndex);
+                    this.messageBuffer = this.messageBuffer.substring(newlineIndex + 1);
+                    if (line.trim()) {
+                        this.handleJsonRpcResponse(line);
+                    }
+                }
+            });
+            this.jsonRpcSocket.on('error', (error) => {
+                this.emit('error', error);
+                reject(error);
+            });
+            this.jsonRpcSocket.on('close', () => {
+                this.connected = false;
+                this.emit('disconnected');
+                this.scheduleReconnect();
+            });
+        });
+    }
+    /**
+     * Handle a line of JSON output from signal-cli
+     */
+    handleJsonLine(line) {
+        try {
+            const data = JSON.parse(line);
+            if (data.envelope) {
+                const message = {
+                    envelope: data.envelope,
+                    account: data.account || this.options.phoneNumber,
+                };
+                // Route to appropriate handler
+                if (data.envelope.dataMessage) {
+                    this.emit('message', message);
+                }
+                else if (data.envelope.receiptMessage) {
+                    this.emit('receipt', data.envelope.receiptMessage, data.envelope.source);
+                }
+                else if (data.envelope.typingMessage) {
+                    this.emit('typing', data.envelope.typingMessage, data.envelope.source);
+                }
+            }
+        }
+        catch (error) {
+            if (this.options.verbose) {
+                console.error('Failed to parse signal-cli output:', line, error);
+            }
+        }
+    }
+    /**
+     * Handle JSON-RPC response
+     */
+    handleJsonRpcResponse(line) {
+        try {
+            const data = JSON.parse(line);
+            // Check if it's a response to a request
+            if (data.id !== undefined && this.pendingRequests.has(data.id)) {
+                const { resolve, reject } = this.pendingRequests.get(data.id);
+                this.pendingRequests.delete(data.id);
+                if (data.error) {
+                    reject(new Error(data.error.message || 'Unknown error'));
+                }
+                else {
+                    resolve(data.result);
+                }
+                return;
+            }
+            // Otherwise treat as event/message
+            if (data.method === 'receive' && data.params) {
+                this.handleJsonLine(JSON.stringify(data.params));
+            }
+        }
+        catch (error) {
+            if (this.options.verbose) {
+                console.error('Failed to parse JSON-RPC response:', line, error);
+            }
+        }
+    }
+    /**
+     * Schedule reconnection attempt
+     */
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            return;
+        }
+        this.reconnectTimer = setTimeout(async () => {
+            this.reconnectTimer = undefined;
+            try {
+                await this.startReceiving();
+            }
+            catch (error) {
+                console.error('Reconnection failed:', error);
+                this.scheduleReconnect();
+            }
+        }, 5000);
+    }
+    /**
+     * Stop receiving messages
+     */
+    async stopReceiving() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        if (this.receiveProcess) {
+            this.receiveProcess.kill('SIGTERM');
+            this.receiveProcess = undefined;
+        }
+        if (this.jsonRpcSocket) {
+            this.jsonRpcSocket.destroy();
+            this.jsonRpcSocket = undefined;
+        }
+        this.connected = false;
+        this.emit('disconnected');
+    }
+    /**
+     * Send a message
+     */
+    async sendMessage(recipient, message, options) {
+        const args = [
+            '-a', this.options.phoneNumber,
+            '--output', 'json',
+            'send',
+        ];
+        if (options?.groupId) {
+            args.push('-g', options.groupId);
+        }
+        else {
+            args.push(recipient);
+        }
+        args.push('-m', message);
+        if (options?.attachments) {
+            for (const attachment of options.attachments) {
+                args.push('-a', attachment);
+            }
+        }
+        if (options?.quote) {
+            args.push('--quote-timestamp', options.quote.timestamp.toString());
+            args.push('--quote-author', options.quote.author);
+        }
+        const result = await this.execCommand(args);
+        // Parse timestamp from result
+        try {
+            const data = JSON.parse(result);
+            return { timestamp: data.timestamp || Date.now() };
+        }
+        catch {
+            return { timestamp: Date.now() };
+        }
+    }
+    /**
+     * Send a reaction
+     */
+    async sendReaction(recipient, emoji, targetAuthor, targetTimestamp, remove = false) {
+        const args = [
+            '-a', this.options.phoneNumber,
+            'sendReaction',
+            recipient,
+            '-e', emoji,
+            '-a', targetAuthor,
+            '-t', targetTimestamp.toString(),
+        ];
+        if (remove) {
+            args.push('-r');
+        }
+        await this.execCommand(args);
+    }
+    /**
+     * Send typing indicator
+     */
+    async sendTyping(recipient, stop = false) {
+        const args = [
+            '-a', this.options.phoneNumber,
+            'sendTyping',
+            recipient,
+        ];
+        if (stop) {
+            args.push('-s');
+        }
+        await this.execCommand(args);
+    }
+    /**
+     * Send read receipt
+     */
+    async sendReadReceipt(sender, timestamps) {
+        const args = [
+            '-a', this.options.phoneNumber,
+            'sendReceipt',
+            '--type', 'read',
+            sender,
+            '-t', ...timestamps.map(String),
+        ];
+        await this.execCommand(args);
+    }
+    /**
+     * Get contacts
+     */
+    async getContacts() {
+        const args = [
+            '-a', this.options.phoneNumber,
+            '--output', 'json',
+            'listContacts',
+        ];
+        const result = await this.execCommand(args);
+        try {
+            return JSON.parse(result);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get groups
+     */
+    async getGroups() {
+        const args = [
+            '-a', this.options.phoneNumber,
+            '--output', 'json',
+            'listGroups',
+            '-d',
+        ];
+        const result = await this.execCommand(args);
+        try {
+            return JSON.parse(result);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Trust a contact's identity
+     */
+    async trustIdentity(phoneNumber, trustAllKnownKeys = false) {
+        const args = [
+            '-a', this.options.phoneNumber,
+            'trust',
+            phoneNumber,
+        ];
+        if (trustAllKnownKeys) {
+            args.push('-a');
+        }
+        await this.execCommand(args);
+    }
+    /**
+     * Download an attachment
+     */
+    async downloadAttachment(attachmentId, outputPath) {
+        // Attachments are automatically downloaded to the data directory
+        const attachmentPath = path.join(this.options.dataDir, 'attachments', attachmentId);
+        if (fs.existsSync(attachmentPath)) {
+            // Copy to output path if different
+            if (attachmentPath !== outputPath) {
+                fs.copyFileSync(attachmentPath, outputPath);
+            }
+            return outputPath;
+        }
+        throw new Error(`Attachment not found: ${attachmentId}`);
+    }
+    /**
+     * Execute a signal-cli command
+     */
+    execCommand(args) {
+        return new Promise((resolve, reject) => {
+            const fullArgs = [...args];
+            if (this.options.verbose) {
+                console.log(`Executing: ${this.options.cliPath} ${fullArgs.join(' ')}`);
+            }
+            (0, child_process_1.exec)(`${this.options.cliPath} ${fullArgs.map(a => `"${a}"`).join(' ')}`, {
+                timeout: 30000,
+                maxBuffer: 10 * 1024 * 1024, // 10MB
+            }, (error, stdout, stderr) => {
+                if (error) {
+                    reject(new Error(stderr || error.message));
+                    return;
+                }
+                resolve(stdout);
+            });
+        });
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Get phone number
+     */
+    getPhoneNumber() {
+        return this.options.phoneNumber;
+    }
+}
+exports.SignalClient = SignalClient;