signal-sdk 0.0.9 → 0.1.1

package/dist/SignalCli.js

@@ -39,11 +39,27 @@ const uuid_1 = require("uuid");
 const qrcodeTerminal = __importStar(require("qrcode-terminal"));
 const events_1 = require("events");
 const path = __importStar(require("path"));
+const validators_1 = require("./validators");
+const retry_1 = require("./retry");
+const config_1 = require("./config");
+const errors_1 = require("./errors");
 class SignalCli extends events_1.EventEmitter {
-    constructor(accountOrPath, account) {
+    constructor(accountOrPath, account, config = {}) {
         super();
         this.cliProcess = null;
         this.requestPromises = new Map();
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        // Validate and merge configuration
+        this.config = (0, config_1.validateConfig)(config);
+        // Initialize logger
+        this.logger = new config_1.Logger({
+            level: this.config.verbose ? 'debug' : 'info',
+            enableFile: !!this.config.logFile,
+            filePath: this.config.logFile
+        });
+        // Initialize rate limiter
+        this.rateLimiter = new retry_1.RateLimiter(this.config.maxConcurrentRequests, this.config.minRequestInterval);
         let signalCliPath;
         let phoneNumber;
         // Smart parameter detection
@@ -72,6 +88,25 @@ class SignalCli extends events_1.EventEmitter {
         this.account = phoneNumber;
     }
     async connect() {
+        const daemonMode = this.config.daemonMode || 'json-rpc';
+        switch (daemonMode) {
+            case 'json-rpc':
+                await this.connectJsonRpc();
+                break;
+            case 'unix-socket':
+                await this.connectUnixSocket();
+                break;
+            case 'tcp':
+                await this.connectTcp();
+                break;
+            case 'http':
+                await this.connectHttp();
+                break;
+            default:
+                throw new Error(`Invalid daemon mode: ${daemonMode}`);
+        }
+    }
+    async connectJsonRpc() {
         const args = this.account ? ['-a', this.account, 'jsonRpc'] : ['jsonRpc'];
         if (process.platform === 'win32') {
             // On Windows, use cmd.exe to run the batch file with proper quoting for paths with spaces
@@ -117,11 +152,120 @@ class SignalCli extends events_1.EventEmitter {
             });
         });
     }
+    async connectUnixSocket() {
+        const net = await Promise.resolve().then(() => __importStar(require('net')));
+        const socketPath = this.config.socketPath || '/tmp/signal-cli.sock';
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection(socketPath);
+            socket.on('connect', () => {
+                this.logger.debug('Connected to Unix socket:', socketPath);
+                socket.on('data', (data) => this.handleRpcResponse(data.toString('utf8')));
+                socket.on('error', (err) => this.emit('error', err));
+                socket.on('close', () => {
+                    this.emit('close', 0);
+                });
+                this.socket = socket;
+                resolve();
+            });
+            socket.on('error', (err) => {
+                reject(new errors_1.ConnectionError(`Failed to connect to Unix socket: ${err.message}`));
+            });
+            setTimeout(() => reject(new errors_1.ConnectionError('Unix socket connection timeout')), this.config.connectionTimeout);
+        });
+    }
+    async connectTcp() {
+        const net = await Promise.resolve().then(() => __importStar(require('net')));
+        const host = this.config.tcpHost || 'localhost';
+        const port = this.config.tcpPort || 7583;
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection(port, host);
+            socket.on('connect', () => {
+                this.logger.debug(`Connected to TCP: ${host}:${port}`);
+                socket.on('data', (data) => this.handleRpcResponse(data.toString('utf8')));
+                socket.on('error', (err) => this.emit('error', err));
+                socket.on('close', () => {
+                    this.emit('close', 0);
+                });
+                this.socket = socket;
+                resolve();
+            });
+            socket.on('error', (err) => {
+                reject(new errors_1.ConnectionError(`Failed to connect to TCP: ${err.message}`));
+            });
+            setTimeout(() => reject(new errors_1.ConnectionError('TCP connection timeout')), this.config.connectionTimeout);
+        });
+    }
+    async connectHttp() {
+        const baseUrl = this.config.httpBaseUrl || 'http://localhost:8080';
+        // For HTTP mode, we don't maintain a persistent connection
+        // Instead, we'll use the httpRequest method for each operation
+        this.logger.debug('HTTP mode configured:', baseUrl);
+        this.httpBaseUrl = baseUrl;
+        // Test connection by sending a simple request
+        try {
+            await this.httpRequest({ jsonrpc: '2.0', method: 'version', params: {}, id: (0, uuid_1.v4)() });
+            this.logger.debug('HTTP connection verified');
+        }
+        catch (error) {
+            throw new errors_1.ConnectionError(`Failed to connect to HTTP endpoint: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async httpRequest(request) {
+        const https = await Promise.resolve(`${this.config.httpBaseUrl?.startsWith('https:') ? 'https' : 'http'}`).then(s => __importStar(require(s)));
+        const baseUrl = this.config.httpBaseUrl || 'http://localhost:8080';
+        const url = new URL('/api/v1/rpc', baseUrl);
+        return new Promise((resolve, reject) => {
+            const data = JSON.stringify(request);
+            const options = {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(data)
+                }
+            };
+            const req = https.request(url, options, (res) => {
+                let body = '';
+                res.on('data', (chunk) => body += chunk);
+                res.on('end', () => {
+                    try {
+                        const response = JSON.parse(body);
+                        if (response.error) {
+                            reject(new Error(`[${response.error.code}] ${response.error.message}`));
+                        }
+                        else {
+                            resolve(response.result);
+                        }
+                    }
+                    catch (error) {
+                        reject(new Error(`Failed to parse HTTP response: ${body}`));
+                    }
+                });
+            });
+            req.on('error', (err) => reject(new errors_1.ConnectionError(`HTTP request failed: ${err.message}`)));
+            req.setTimeout(this.config.requestTimeout, () => {
+                req.destroy();
+                reject(new errors_1.ConnectionError('HTTP request timeout'));
+            });
+            req.write(data);
+            req.end();
+        });
+    }
     disconnect() {
-        if (this.cliProcess) {
+        const daemonMode = this.config.daemonMode || 'json-rpc';
+        // Close socket connections
+        if (daemonMode === 'unix-socket' || daemonMode === 'tcp') {
+            const socket = this.socket;
+            if (socket && !socket.destroyed) {
+                socket.destroy();
+                this.socket = null;
+            }
+        }
+        // Close process for json-rpc mode
+        if (daemonMode === 'json-rpc' && this.cliProcess) {
             this.cliProcess.kill();
             this.cliProcess = null;
         }
+        // For HTTP mode, nothing to disconnect (stateless)
     }
     async gracefulShutdown() {
         return new Promise((resolve) => {
@@ -137,13 +281,17 @@ class SignalCli extends events_1.EventEmitter {
             // Send SIGTERM for graceful shutdown
             this.cliProcess.kill('SIGTERM');
             // Force kill after 5 seconds if it doesn't close gracefully
-            setTimeout(() => {
+            const forceKillTimer = setTimeout(() => {
                 if (this.cliProcess) {
                     this.cliProcess.kill('SIGKILL');
                     this.cliProcess = null;
                     resolve();
                 }
             }, 5000);
+            // Use unref() to prevent this timer from keeping the process alive
+            if (forceKillTimer.unref) {
+                forceKillTimer.unref();
+            }
         });
     }
     handleRpcResponse(data) {
@@ -218,8 +366,40 @@ class SignalCli extends events_1.EventEmitter {
         }
     }
     async sendJsonRpcRequest(method, params) {
+        const daemonMode = this.config.daemonMode || 'json-rpc';
+        // For HTTP mode, use HTTP requests
+        if (daemonMode === 'http') {
+            const id = (0, uuid_1.v4)();
+            const request = {
+                jsonrpc: '2.0',
+                method,
+                params,
+                id,
+            };
+            return await this.httpRequest(request);
+        }
+        // For socket modes (Unix socket, TCP), write to socket
+        if (daemonMode === 'unix-socket' || daemonMode === 'tcp') {
+            const socket = this.socket;
+            if (!socket || socket.destroyed) {
+                throw new errors_1.ConnectionError('Not connected. Call connect() first.');
+            }
+            const id = (0, uuid_1.v4)();
+            const request = {
+                jsonrpc: '2.0',
+                method,
+                params,
+                id,
+            };
+            const promise = new Promise((resolve, reject) => {
+                this.requestPromises.set(id, { resolve, reject });
+            });
+            socket.write(JSON.stringify(request) + '\n');
+            return promise;
+        }
+        // Default JSON-RPC mode with stdin/stdout
         if (!this.cliProcess || !this.cliProcess.stdin) {
-            throw new Error('Not connected. Call connect() first.');
+            throw new errors_1.ConnectionError('Not connected. Call connect() first.');
         }
         const id = (0, uuid_1.v4)();
         const request = {
@@ -256,7 +436,7 @@ class SignalCli extends events_1.EventEmitter {
         else {
             params.recipients = [recipient];
         }
-        // Only add safe, well-known options to avoid JSON parsing issues
+        // Add well-known options
         if (options.attachments && options.attachments.length > 0) {
             params.attachments = options.attachments;
         }
@@ -264,7 +444,64 @@ class SignalCli extends events_1.EventEmitter {
             params.expiresInSeconds = options.expiresInSeconds;
         }
         if (options.isViewOnce) {
-            params.isViewOnce = options.isViewOnce;
+            params.viewOnce = options.isViewOnce;
+        }
+        // Add advanced text formatting options
+        if (options.mentions && options.mentions.length > 0) {
+            params.mentions = options.mentions.map(m => ({
+                start: m.start,
+                length: m.length,
+                number: m.recipient || m.number
+            }));
+        }
+        if (options.textStyles && options.textStyles.length > 0) {
+            params.textStyles = options.textStyles.map(ts => ({
+                start: ts.start,
+                length: ts.length,
+                style: ts.style
+            }));
+        }
+        // Add quote/reply information
+        if (options.quote) {
+            params.quoteTimestamp = options.quote.timestamp;
+            params.quoteAuthor = options.quote.author;
+            if (options.quote.text) {
+                params.quoteMessage = options.quote.text;
+            }
+            if (options.quote.mentions && options.quote.mentions.length > 0) {
+                params.quoteMentions = options.quote.mentions.map(m => ({
+                    start: m.start,
+                    length: m.length,
+                    number: m.recipient || m.number
+                }));
+            }
+            if (options.quote.textStyles && options.quote.textStyles.length > 0) {
+                params.quoteTextStyles = options.quote.textStyles.map(ts => ({
+                    start: ts.start,
+                    length: ts.length,
+                    style: ts.style
+                }));
+            }
+        }
+        // Add preview URL
+        if (options.previewUrl) {
+            params.previewUrl = options.previewUrl;
+        }
+        // Add edit timestamp for editing existing messages
+        if (options.editTimestamp) {
+            params.editTimestamp = options.editTimestamp;
+        }
+        // Add story reply information
+        if (options.storyTimestamp && options.storyAuthor) {
+            params.storyTimestamp = options.storyTimestamp;
+            params.storyAuthor = options.storyAuthor;
+        }
+        // Add special flags
+        if (options.noteToSelf) {
+            params.noteToSelf = options.noteToSelf;
+        }
+        if (options.endSession) {
+            params.endSession = options.endSession;
         }
         return this.sendJsonRpcRequest('send', params);
     }
@@ -355,6 +592,79 @@ class SignalCli extends events_1.EventEmitter {
     async trustIdentity(number, safetyNumber, verified = true) {
         await this.sendJsonRpcRequest('trust', { account: this.account, recipient: number, safetyNumber, verified });
     }
+    /**
+     * Get the safety number for a specific contact.
+     * This is a helper method that extracts just the safety number from identity information.
+     *
+     * @param number - The phone number of the contact
+     * @returns The safety number string, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const safetyNumber = await signal.getSafetyNumber('+33123456789');
+     * console.log(`Safety number: ${safetyNumber}`);
+     * ```
+     */
+    async getSafetyNumber(number) {
+        const identities = await this.listIdentities(number);
+        if (identities.length > 0 && identities[0].safetyNumber) {
+            return identities[0].safetyNumber;
+        }
+        return null;
+    }
+    /**
+     * Verify a safety number for a contact.
+     * Checks if the provided safety number matches the stored one and marks it as trusted if it does.
+     *
+     * @param number - The phone number of the contact
+     * @param safetyNumber - The safety number to verify
+     * @returns True if the safety number matches and was trusted, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const verified = await signal.verifySafetyNumber('+33123456789', '123456 78901...');
+     * if (verified) {
+     *   console.log('Safety number verified and trusted');
+     * } else {
+     *   console.log('Safety number does not match!');
+     * }
+     * ```
+     */
+    async verifySafetyNumber(number, safetyNumber) {
+        const storedSafetyNumber = await this.getSafetyNumber(number);
+        if (!storedSafetyNumber) {
+            return false;
+        }
+        // Compare safety numbers (remove spaces for comparison)
+        const normalizedStored = storedSafetyNumber.replace(/\s/g, '');
+        const normalizedProvided = safetyNumber.replace(/\s/g, '');
+        if (normalizedStored === normalizedProvided) {
+            await this.trustIdentity(number, safetyNumber, true);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * List all untrusted identities.
+     * Returns identities that have not been explicitly trusted.
+     *
+     * @returns Array of untrusted identity keys
+     *
+     * @example
+     * ```typescript
+     * const untrusted = await signal.listUntrustedIdentities();
+     * console.log(`Found ${untrusted.length} untrusted identities`);
+     * untrusted.forEach(id => {
+     *   console.log(`${id.number}: ${id.safetyNumber}`);
+     * });
+     * ```
+     */
+    async listUntrustedIdentities() {
+        const allIdentities = await this.listIdentities();
+        return allIdentities.filter(identity => identity.trustLevel === 'UNTRUSTED' ||
+            identity.trustLevel === 'TRUST_ON_FIRST_USE' ||
+            !identity.trustLevel);
+    }
     async link(deviceName) {
         const result = await this.sendJsonRpcRequest('link', { deviceName });
         return result.uri;
@@ -489,6 +799,10 @@ class SignalCli extends events_1.EventEmitter {
             params.promoteAdmins = options.promoteAdmins;
         if (options.demoteAdmins)
             params.demoteAdmins = options.demoteAdmins;
+        if (options.banMembers)
+            params.banMembers = options.banMembers;
+        if (options.unbanMembers)
+            params.unbanMembers = options.unbanMembers;
         if (options.resetInviteLink)
             params.resetLink = true;
         if (options.permissionAddMember)
@@ -504,6 +818,58 @@ class SignalCli extends events_1.EventEmitter {
     async listGroups() {
         return this.sendJsonRpcRequest('listGroups', { account: this.account });
     }
+    /**
+     * Send group invite link to a recipient.
+     * Retrieves and sends the invitation link for a group.
+     *
+     * @param groupId - The group ID
+     * @param recipient - The recipient to send the invite link to
+     * @returns Send response
+     *
+     * @example
+     * ```typescript
+     * await signal.sendGroupInviteLink('groupId123==', '+33123456789');
+     * ```
+     */
+    async sendGroupInviteLink(groupId, recipient) {
+        // Get group info to retrieve invite link
+        const groups = await this.listGroups();
+        const group = groups.find(g => g.groupId === groupId);
+        const inviteLink = group?.groupInviteLink || group?.inviteLink;
+        if (!group || !inviteLink) {
+            throw new Error('Group not found or does not have an invite link');
+        }
+        return this.sendMessage(recipient, `Join our group: ${inviteLink}`);
+    }
+    /**
+     * Set banned members for a group.
+     * Ban specific members from the group.
+     *
+     * @param groupId - The group ID
+     * @param members - Array of phone numbers to ban
+     *
+     * @example
+     * ```typescript
+     * await signal.setBannedMembers('groupId123==', ['+33111111111', '+33222222222']);
+     * ```
+     */
+    async setBannedMembers(groupId, members) {
+        await this.updateGroup(groupId, { banMembers: members });
+    }
+    /**
+     * Reset group invite link.
+     * Invalidates the current group invite link and generates a new one.
+     *
+     * @param groupId - The group ID
+     *
+     * @example
+     * ```typescript
+     * await signal.resetGroupLink('groupId123==');
+     * ```
+     */
+    async resetGroupLink(groupId) {
+        await this.updateGroup(groupId, { resetInviteLink: true });
+    }
     async listContacts() {
         return this.sendJsonRpcRequest('listContacts', { account: this.account });
     }
@@ -543,6 +909,101 @@ class SignalCli extends events_1.EventEmitter {
         console.warn("stopDaemon is deprecated. Use gracefulShutdown() or disconnect() instead.");
         this.gracefulShutdown();
     }
+    // ############# MESSAGE RECEIVING #############
+    /**
+     * Receive messages from Signal with configurable options.
+     * This is the modern replacement for the deprecated receiveMessages().
+     *
+     * @param options - Options for receiving messages
+     * @returns Array of received messages
+     *
+     * @example
+     * ```typescript
+     * // Receive with default timeout
+     * const messages = await signal.receive();
+     *
+     * // Receive with custom options
+     * const messages = await signal.receive({
+     *   timeout: 10,
+     *   maxMessages: 5,
+     *   ignoreAttachments: true,
+     *   sendReadReceipts: true
+     * });
+     * ```
+     */
+    async receive(options = {}) {
+        const params = { account: this.account };
+        // Set timeout (default: 5 seconds)
+        if (options.timeout !== undefined) {
+            params.timeout = options.timeout;
+        }
+        // Set maximum number of messages
+        if (options.maxMessages !== undefined) {
+            params.maxMessages = options.maxMessages;
+        }
+        // Skip attachment downloads
+        if (options.ignoreAttachments) {
+            params.ignoreAttachments = true;
+        }
+        // Skip stories
+        if (options.ignoreStories) {
+            params.ignoreStories = true;
+        }
+        // Send read receipts automatically
+        if (options.sendReadReceipts) {
+            params.sendReadReceipts = true;
+        }
+        try {
+            const result = await this.sendJsonRpcRequest('receive', params);
+            // Parse and return messages
+            if (Array.isArray(result)) {
+                return result.map(envelope => this.parseEnvelope(envelope));
+            }
+            return [];
+        }
+        catch (error) {
+            this.logger.error('Failed to receive messages:', error);
+            throw error;
+        }
+    }
+    /**
+     * Parse a message envelope from signal-cli into a Message object.
+     * @private
+     */
+    parseEnvelope(envelope) {
+        const message = {
+            timestamp: envelope.timestamp || Date.now(),
+            source: envelope.source || envelope.sourceNumber,
+            sourceUuid: envelope.sourceUuid,
+            sourceDevice: envelope.sourceDevice,
+        };
+        // Parse data message
+        if (envelope.dataMessage) {
+            const data = envelope.dataMessage;
+            message.text = data.message || data.body;
+            message.groupId = data.groupInfo?.groupId;
+            message.attachments = data.attachments;
+            message.mentions = data.mentions;
+            message.quote = data.quote;
+            message.reaction = data.reaction;
+            message.sticker = data.sticker;
+            message.expiresInSeconds = data.expiresInSeconds;
+            message.viewOnce = data.viewOnce;
+        }
+        // Parse sync message
+        if (envelope.syncMessage) {
+            message.syncMessage = envelope.syncMessage;
+        }
+        // Parse receipt message
+        if (envelope.receiptMessage) {
+            message.receipt = envelope.receiptMessage;
+        }
+        // Parse typing message
+        if (envelope.typingMessage) {
+            message.typing = envelope.typingMessage;
+        }
+        return message;
+    }
     // ############# NEW FEATURES - Missing signal-cli Commands #############
     /**
      * Remove a contact from the contact list.
@@ -588,12 +1049,29 @@ class SignalCli extends events_1.EventEmitter {
         return statusResults;
     }
     /**
-     * Send a payment notification to a recipient.
-     * @param recipient - Phone number or group ID to send the notification to
-     * @param paymentData - Payment notification data including receipt
-     * @returns Send response with timestamp and other details
+     * Send a payment notification to a recipient (MobileCoin).
+     * Sends a notification about a cryptocurrency payment made through Signal's MobileCoin integration.
+     *
+     * @param recipient - The phone number or group ID of the recipient
+     * @param paymentData - Payment notification data including receipt and optional note
+     * @returns Send result with timestamp
+     * @throws {Error} If receipt is invalid or sending fails
+     *
+     * @example
+     * ```typescript
+     * const receiptBlob = 'base64EncodedReceiptData...';
+     * await signal.sendPaymentNotification('+33612345678', {
+     *   receipt: receiptBlob,
+     *   note: 'Thanks for dinner!'
+     * });
+     * ```
      */
     async sendPaymentNotification(recipient, paymentData) {
+        this.logger.info(`Sending payment notification to ${recipient}`);
+        (0, validators_1.validateRecipient)(recipient);
+        if (!paymentData.receipt || paymentData.receipt.trim().length === 0) {
+            throw new Error('Payment receipt is required');
+        }
         const params = {
             receipt: paymentData.receipt,
             account: this.account
@@ -646,13 +1124,18 @@ class SignalCli extends events_1.EventEmitter {
         };
     }
     /**
-     * Start the process of changing phone number.
-     * @param newNumber - The new phone number to change to
-     * @param voice - Whether to use voice verification instead of SMS
-     * @param captcha - Captcha token if required
-     * @returns Change number session information
+     * Start the phone number change process.
+     * Initiates SMS or voice verification for changing your account to a new phone number.
+     * After calling this, you must verify the new number with finishChangeNumber().
+     *
+     * @param newNumber - The new phone number in E164 format (e.g., "+33612345678")
+     * @param voice - Use voice verification instead of SMS (default: false)
+     * @param captcha - Optional captcha token if required
+     * @throws {Error} If not a primary device or rate limited
      */
     async startChangeNumber(newNumber, voice = false, captcha) {
+        this.logger.info(`Starting change number to ${newNumber} (voice: ${voice})`);
+        (0, validators_1.validatePhoneNumber)(newNumber);
         const params = {
             account: this.account,
             number: newNumber,
@@ -660,22 +1143,28 @@ class SignalCli extends events_1.EventEmitter {
         };
         if (captcha)
             params.captcha = captcha;
-        const result = await this.sendJsonRpcRequest('startChangeNumber', params);
-        return {
-            session: result.session,
-            newNumber,
-            challenge: result.challenge
-        };
+        await this.sendJsonRpcRequest('startChangeNumber', params);
     }
     /**
-     * Finish the phone number change process with verification code.
-     * @param verificationCode - The verification code received via SMS/voice
-     * @param pin - Registration lock PIN if enabled
+     * Complete the phone number change process.
+     * Verifies the code received via SMS or voice and changes your account to the new number.
+     * Must be called after startChangeNumber().
+     *
+     * @param newNumber - The new phone number (same as startChangeNumber)
+     * @param verificationCode - The verification code received via SMS or voice
+     * @param pin - Optional registration lock PIN if one was set
+     * @throws {Error} If verification fails or incorrect PIN
      */
-    async finishChangeNumber(verificationCode, pin) {
+    async finishChangeNumber(newNumber, verificationCode, pin) {
+        this.logger.info(`Finishing change number to ${newNumber}`);
+        (0, validators_1.validatePhoneNumber)(newNumber);
+        if (!verificationCode || verificationCode.trim().length === 0) {
+            throw new Error('Verification code is required');
+        }
         const params = {
             account: this.account,
-            code: verificationCode
+            number: newNumber,
+            verificationCode
         };
         if (pin)
             params.pin = pin;
@@ -707,5 +1196,370 @@ class SignalCli extends events_1.EventEmitter {
         }
         return this.sendMessage(recipient, message, sendOptions);
     }
+    // ========== NEW METHODS FOR 100% signal-cli COMPATIBILITY ==========
+    /**
+     * Send a poll create message to a recipient or group.
+     * @param options Poll creation options
+     * @returns Send response with timestamp
+     */
+    async sendPollCreate(options) {
+        this.logger.debug('Sending poll create', options);
+        (0, validators_1.validateMessage)(options.question, 500);
+        if (!options.options || options.options.length < 2) {
+            throw new errors_1.MessageError('Poll must have at least 2 options');
+        }
+        if (options.options.length > 10) {
+            throw new errors_1.MessageError('Poll cannot have more than 10 options');
+        }
+        const params = {
+            question: options.question,
+            options: options.options,
+            account: this.account
+        };
+        if (options.multiSelect !== undefined) {
+            params.multiSelect = options.multiSelect;
+        }
+        if (options.groupId) {
+            (0, validators_1.validateGroupId)(options.groupId);
+            params.groupId = options.groupId;
+        }
+        else if (options.recipients) {
+            params.recipients = options.recipients.map(r => {
+                (0, validators_1.validateRecipient)(r);
+                return r;
+            });
+        }
+        else {
+            throw new errors_1.MessageError('Must specify either recipients or groupId');
+        }
+        return this.sendJsonRpcRequest('sendPollCreate', params);
+    }
+    /**
+     * Send a poll vote message to vote on a poll.
+     * @param recipient Recipient or group ID
+     * @param options Poll vote options
+     * @returns Send response with timestamp
+     */
+    async sendPollVote(recipient, options) {
+        this.logger.debug('Sending poll vote', { recipient, options });
+        (0, validators_1.validateRecipient)(options.pollAuthor);
+        (0, validators_1.validateTimestamp)(options.pollTimestamp);
+        if (!options.optionIndexes || options.optionIndexes.length === 0) {
+            throw new errors_1.MessageError('Must specify at least one option to vote for');
+        }
+        const params = {
+            pollAuthor: options.pollAuthor,
+            pollTimestamp: options.pollTimestamp,
+            options: options.optionIndexes,
+            account: this.account
+        };
+        if (options.voteCount !== undefined) {
+            params.voteCount = options.voteCount;
+        }
+        if (this.isGroupId(recipient)) {
+            (0, validators_1.validateGroupId)(recipient);
+            params.groupId = recipient;
+        }
+        else {
+            (0, validators_1.validateRecipient)(recipient);
+            params.recipient = recipient;
+        }
+        return this.sendJsonRpcRequest('sendPollVote', params);
+    }
+    /**
+     * Send a poll terminate message to close a poll.
+     * @param recipient Recipient or group ID
+     * @param options Poll terminate options
+     * @returns Send response with timestamp
+     */
+    async sendPollTerminate(recipient, options) {
+        this.logger.debug('Sending poll terminate', { recipient, options });
+        (0, validators_1.validateTimestamp)(options.pollTimestamp);
+        const params = {
+            pollTimestamp: options.pollTimestamp,
+            account: this.account
+        };
+        if (this.isGroupId(recipient)) {
+            (0, validators_1.validateGroupId)(recipient);
+            params.groupId = recipient;
+        }
+        else {
+            (0, validators_1.validateRecipient)(recipient);
+            params.recipient = recipient;
+        }
+        return this.sendJsonRpcRequest('sendPollTerminate', params);
+    }
+    /**
+     * Update account information (device name, username, privacy settings).
+     * @param options Account update options
+     * @returns Account update result
+     */
+    async updateAccount(options) {
+        this.logger.debug('Updating account', options);
+        const params = { account: this.account };
+        if (options.deviceName) {
+            params.deviceName = options.deviceName;
+        }
+        if (options.username) {
+            params.username = options.username;
+        }
+        if (options.deleteUsername) {
+            params.deleteUsername = true;
+        }
+        if (options.unrestrictedUnidentifiedSender !== undefined) {
+            params.unrestrictedUnidentifiedSender = options.unrestrictedUnidentifiedSender;
+        }
+        if (options.discoverableByNumber !== undefined) {
+            params.discoverableByNumber = options.discoverableByNumber;
+        }
+        if (options.numberSharing !== undefined) {
+            params.numberSharing = options.numberSharing;
+        }
+        try {
+            const result = await this.sendJsonRpcRequest('updateAccount', params);
+            return {
+                success: true,
+                username: result.username,
+                usernameLink: result.usernameLink
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Set or update the username for this account.
+     * Helper method that wraps updateAccount() for simpler username management.
+     *
+     * @param username - The username to set (without discriminator)
+     * @returns Account update result with username and link
+     *
+     * @example
+     * ```typescript
+     * const result = await signal.setUsername('myusername');
+     * console.log(`Username: ${result.username}`);
+     * console.log(`Link: ${result.usernameLink}`);
+     * ```
+     */
+    async setUsername(username) {
+        return this.updateAccount({ username });
+    }
+    /**
+     * Delete the current username from this account.
+     * Helper method that wraps updateAccount() for simpler username deletion.
+     *
+     * @returns Account update result
+     *
+     * @example
+     * ```typescript
+     * const result = await signal.deleteUsername();
+     * if (result.success) {
+     *   console.log('Username deleted successfully');
+     * }
+     * ```
+     */
+    async deleteUsername() {
+        return this.updateAccount({ deleteUsername: true });
+    }
+    /**
+     * Get raw attachment data as base64 string.
+     * @param options Attachment retrieval options
+     * @returns Base64 encoded attachment data
+     */
+    async getAttachment(options) {
+        this.logger.debug('Getting attachment', options);
+        if (!options.id) {
+            throw new errors_1.MessageError('Attachment ID is required');
+        }
+        const params = {
+            id: options.id,
+            account: this.account
+        };
+        if (options.groupId) {
+            (0, validators_1.validateGroupId)(options.groupId);
+            params.groupId = options.groupId;
+        }
+        else if (options.recipient) {
+            (0, validators_1.validateRecipient)(options.recipient);
+            params.recipient = options.recipient;
+        }
+        const result = await this.sendJsonRpcRequest('getAttachment', params);
+        return result.data || result;
+    }
+    /**
+     * Get raw avatar data as base64 string.
+     * @param options Avatar retrieval options
+     * @returns Base64 encoded avatar data
+     */
+    async getAvatar(options) {
+        this.logger.debug('Getting avatar', options);
+        const params = { account: this.account };
+        if (options.contact) {
+            (0, validators_1.validateRecipient)(options.contact);
+            params.contact = options.contact;
+        }
+        else if (options.profile) {
+            (0, validators_1.validateRecipient)(options.profile);
+            params.profile = options.profile;
+        }
+        else if (options.groupId) {
+            (0, validators_1.validateGroupId)(options.groupId);
+            params.groupId = options.groupId;
+        }
+        else {
+            throw new errors_1.MessageError('Must specify contact, profile, or groupId');
+        }
+        const result = await this.sendJsonRpcRequest('getAvatar', params);
+        return result.data || result;
+    }
+    /**
+     * Get raw sticker data as base64 string.
+     * @param options Sticker retrieval options
+     * @returns Base64 encoded sticker data
+     */
+    async getSticker(options) {
+        this.logger.debug('Getting sticker', options);
+        if (!options.packId || !options.stickerId) {
+            throw new errors_1.MessageError('Pack ID and sticker ID are required');
+        }
+        const params = {
+            packId: options.packId,
+            stickerId: options.stickerId,
+            account: this.account
+        };
+        const result = await this.sendJsonRpcRequest('getSticker', params);
+        return result.data || result;
+    }
+    /**
+     * Send contacts synchronization message to linked devices.
+     * @param options Contacts sync options
+     */
+    async sendContacts(options = {}) {
+        this.logger.debug('Sending contacts sync');
+        const params = { account: this.account };
+        if (options.includeAllRecipients) {
+            params.allRecipients = true;
+        }
+        await this.sendJsonRpcRequest('sendContacts', params);
+    }
+    /**
+     * List groups with optional filtering and details.
+     * @param options List groups options
+     * @returns Array of group information
+     */
+    async listGroupsDetailed(options = {}) {
+        this.logger.debug('Listing groups with options', options);
+        const params = { account: this.account };
+        if (options.detailed) {
+            params.detailed = true;
+        }
+        if (options.groupIds && options.groupIds.length > 0) {
+            params.groupId = options.groupIds;
+        }
+        return this.sendJsonRpcRequest('listGroups', params);
+    }
+    /**
+     * List all local accounts.
+     * @returns Array of account phone numbers
+     */
+    async listAccountsDetailed() {
+        this.logger.debug('Listing all accounts');
+        const result = await this.sendJsonRpcRequest('listAccounts');
+        return result.accounts || [];
+    }
+    /**
+     * Extract profile information from a contact.
+     * Parses givenName, familyName, mobileCoinAddress from profile data.
+     *
+     * @param contact - The contact object to parse
+     * @returns Enhanced contact with extracted profile fields
+     *
+     * @example
+     * ```typescript
+     * const contacts = await signal.listContacts();
+     * const enriched = signal.parseContactProfile(contacts[0]);
+     * console.log(enriched.givenName, enriched.familyName);
+     * ```
+     */
+    parseContactProfile(contact) {
+        // signal-cli already provides these fields if available
+        // This method normalizes and validates the data
+        return {
+            ...contact,
+            givenName: contact.givenName || undefined,
+            familyName: contact.familyName || undefined,
+            mobileCoinAddress: contact.mobileCoinAddress || undefined,
+            profileName: contact.profileName ||
+                (contact.givenName && contact.familyName
+                    ? `${contact.givenName} ${contact.familyName}`
+                    : contact.givenName || contact.familyName),
+        };
+    }
+    /**
+     * Extract group membership details.
+     * Parses pendingMembers, bannedMembers, inviteLink from group data.
+     *
+     * @param group - The group info to parse
+     * @returns Enhanced group with extracted membership fields
+     *
+     * @example
+     * ```typescript
+     * const groups = await signal.listGroups();
+     * const enriched = signal.parseGroupDetails(groups[0]);
+     * console.log(enriched.pendingMembers, enriched.bannedMembers);
+     * ```
+     */
+    parseGroupDetails(group) {
+        return {
+            ...group,
+            // Normalize inviteLink field
+            inviteLink: group.groupInviteLink || group.inviteLink,
+            groupInviteLink: group.groupInviteLink || group.inviteLink,
+            // Ensure arrays exist
+            pendingMembers: group.pendingMembers || [],
+            banned: group.banned || [],
+            requestingMembers: group.requestingMembers || [],
+            admins: group.admins || [],
+            members: group.members || [],
+        };
+    }
+    /**
+     * Get enriched contacts list with parsed profile information.
+     *
+     * @returns Array of contacts with full profile data
+     *
+     * @example
+     * ```typescript
+     * const contacts = await signal.getContactsWithProfiles();
+     * contacts.forEach(c => {
+     *   console.log(`${c.givenName} ${c.familyName} - ${c.mobileCoinAddress}`);
+     * });
+     * ```
+     */
+    async getContactsWithProfiles() {
+        const contacts = await this.listContacts();
+        return contacts.map(c => this.parseContactProfile(c));
+    }
+    /**
+     * Get enriched groups list with parsed membership details.
+     *
+     * @param options - List groups options
+     * @returns Array of groups with full membership data
+     *
+     * @example
+     * ```typescript
+     * const groups = await signal.getGroupsWithDetails();
+     * groups.forEach(g => {
+     *   console.log(`${g.name}: ${g.members.length} members, ${g.pendingMembers.length} pending`);
+     * });
+     * ```
+     */
+    async getGroupsWithDetails(options = {}) {
+        const groups = await this.listGroupsDetailed(options);
+        return groups.map(g => this.parseGroupDetails(g));
+    }
 }
 exports.SignalCli = SignalCli;