signal-sdk 0.1.1 → 0.1.3

package/dist/SignalCli.js

@@ -43,6 +43,12 @@ const validators_1 = require("./validators");
 const retry_1 = require("./retry");
 const config_1 = require("./config");
 const errors_1 = require("./errors");
+const MessageManager_1 = require("./managers/MessageManager");
+const GroupManager_1 = require("./managers/GroupManager");
+const ContactManager_1 = require("./managers/ContactManager");
+const DeviceManager_1 = require("./managers/DeviceManager");
+const AccountManager_1 = require("./managers/AccountManager");
+const StickerManager_1 = require("./managers/StickerManager");
 class SignalCli extends events_1.EventEmitter {
     constructor(accountOrPath, account, config = {}) {
         super();
@@ -56,7 +62,7 @@ class SignalCli extends events_1.EventEmitter {
         this.logger = new config_1.Logger({
             level: this.config.verbose ? 'debug' : 'info',
             enableFile: !!this.config.logFile,
-            filePath: this.config.logFile
+            filePath: this.config.logFile,
         });
         // Initialize rate limiter
         this.rateLimiter = new retry_1.RateLimiter(this.config.maxConcurrentRequests, this.config.minRequestInterval);
@@ -86,6 +92,25 @@ class SignalCli extends events_1.EventEmitter {
         }
         this.signalCliPath = signalCliPath || defaultPath;
         this.account = phoneNumber;
+        // Validate account if provided
+        if (this.account) {
+            (0, validators_1.validatePhoneNumber)(this.account);
+        }
+        // Validate CLI path
+        (0, validators_1.validateSanitizedString)(this.signalCliPath, 'signalCliPath');
+        // Initialize Managers
+        const rpcCall = (method, params) => {
+            if (params === undefined) {
+                return this.sendJsonRpcRequest(method);
+            }
+            return this.sendJsonRpcRequest(method, params);
+        };
+        this.messages = new MessageManager_1.MessageManager(rpcCall, this.account, this.logger, this.config);
+        this.groups = new GroupManager_1.GroupManager(rpcCall, this.account, this.logger, this.config);
+        this.contacts = new ContactManager_1.ContactManager(rpcCall, this.account, this.logger, this.config);
+        this.devices = new DeviceManager_1.DeviceManager(rpcCall, this.account, this.logger, this.config, this.signalCliPath);
+        this.accounts = new AccountManager_1.AccountManager(rpcCall, this.account, this.logger, this.config);
+        this.stickers = new StickerManager_1.StickerManager(rpcCall, this.account, this.logger, this.config);
     }
     async connect() {
         const daemonMode = this.config.daemonMode || 'json-rpc';
@@ -117,10 +142,7 @@ class SignalCli extends events_1.EventEmitter {
         }
         this.cliProcess.stdout?.on('data', (data) => this.handleRpcResponse(data.toString('utf8')));
         this.cliProcess.stderr?.on('data', (data) => this.handleStderrData(data.toString('utf8')));
-        this.cliProcess.on('close', (code) => {
-            this.emit('close', code);
-            this.cliProcess = null;
-        });
+        this.cliProcess.on('close', (code) => this.handleProcessClose(code));
         this.cliProcess.on('error', (err) => this.emit('error', err));
         return new Promise((resolve, reject) => {
             // Set a timeout to resolve the promise even if no data is received
@@ -146,7 +168,8 @@ class SignalCli extends events_1.EventEmitter {
             // If the process exits immediately, that's an error
             this.cliProcess?.once('close', (code) => {
                 clearTimeout(connectTimeout);
-                if (code !== 0) {
+                if (code !== 0 && !this.cliProcess) {
+                    // Only reject if not trying to reconnect or already null
                     reject(new Error(`signal-cli exited with code ${code}`));
                 }
             });
@@ -220,12 +243,12 @@ class SignalCli extends events_1.EventEmitter {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
-                    'Content-Length': Buffer.byteLength(data)
-                }
+                    'Content-Length': Buffer.byteLength(data),
+                },
             };
             const req = https.request(url, options, (res) => {
                 let body = '';
-                res.on('data', (chunk) => body += chunk);
+                res.on('data', (chunk) => (body += chunk));
                 res.on('end', () => {
                     try {
                         const response = JSON.parse(body);
@@ -317,6 +340,9 @@ class SignalCli extends events_1.EventEmitter {
                     this.emit('notification', response);
                     if (response.method === 'receive') {
                         this.emit('message', response.params);
+                        if (response.params && response.params.envelope) {
+                            this.emitDetailedEvents(response.params.envelope);
+                        }
                     }
                 }
             }
@@ -325,6 +351,72 @@ class SignalCli extends events_1.EventEmitter {
             }
         }
     }
+    emitDetailedEvents(envelope) {
+        const source = envelope.source || envelope.sourceNumber;
+        const timestamp = envelope.timestamp;
+        // 1. Reaction
+        if (envelope.dataMessage?.reaction) {
+            this.emit('reaction', {
+                emoji: envelope.dataMessage.reaction.emoji,
+                sender: source,
+                timestamp: timestamp,
+                targetAuthor: envelope.dataMessage.reaction.targetAuthor,
+                targetTimestamp: envelope.dataMessage.reaction.targetSentTimestamp,
+                isRemove: envelope.dataMessage.reaction.isRemove,
+            });
+        }
+        // 2. Receipt
+        if (envelope.receiptMessage) {
+            this.emit('receipt', {
+                sender: source,
+                timestamp: timestamp,
+                type: envelope.receiptMessage.type,
+                timestamps: envelope.receiptMessage.timestamps,
+                when: envelope.receiptMessage.when,
+            });
+        }
+        // 3. Typing
+        if (envelope.typingMessage) {
+            this.emit('typing', {
+                sender: source,
+                timestamp: timestamp,
+                action: envelope.typingMessage.action,
+                groupId: envelope.typingMessage.groupId,
+            });
+        }
+        // 4. Story (if supported in future or present)
+        if (envelope.storyMessage) {
+            this.emit('story', {
+                sender: source,
+                timestamp: timestamp,
+                ...envelope.storyMessage,
+            });
+        }
+    }
+    async handleProcessClose(code) {
+        this.cliProcess = null;
+        this.emit('close', code);
+        // Auto-reconnect logic if not explicitly disconnected
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.reconnectAttempts++;
+            // Exponential backoff: 1s, 2s, 4s, 8s, 16s...
+            const delay = Math.pow(2, this.reconnectAttempts - 1) * 1000;
+            this.logger.warn(`signal-cli process closed (code ${code}). Reconnecting in ${delay}ms... (Attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+            setTimeout(async () => {
+                try {
+                    await this.connect();
+                    this.reconnectAttempts = 0; // Reset on success
+                    this.logger.info('Reconnected to signal-cli successfully');
+                }
+                catch (error) {
+                    this.logger.error('Reconnection attempt failed:', error);
+                }
+            }, delay);
+        }
+        else {
+            this.logger.error(`Max reconnection attempts reached (${this.maxReconnectAttempts}). Manual intervention required.`);
+        }
+    }
     handleStderrData(data) {
         const message = data.trim();
         if (!message)
@@ -342,12 +434,13 @@ class SignalCli extends events_1.EventEmitter {
             // Emit as a warning event for non-error messages
             this.emit('log', { level: logLevel.toLowerCase(), message });
             // Filter out common informational WARN messages from signal-cli
-            const isInformationalWarn = logLevel === 'WARN' && (message.includes('Failed to get sender certificate') ||
-                message.includes('ignoring: java.lang.InterruptedException') ||
-                message.includes('Request was interrupted') ||
-                message.includes('Connection reset') ||
-                message.includes('Socket closed') ||
-                message.includes('gracefully closing'));
+            const isInformationalWarn = logLevel === 'WARN' &&
+                (message.includes('Failed to get sender certificate') ||
+                    message.includes('ignoring: java.lang.InterruptedException') ||
+                    message.includes('Request was interrupted') ||
+                    message.includes('Connection reset') ||
+                    message.includes('Socket closed') ||
+                    message.includes('gracefully closing'));
             // Only log actual warning messages, not informational ones
             if (logLevel === 'WARN' && !isInformationalWarn) {
                 console.warn(`[signal-cli] ${message}`);
@@ -378,29 +471,6 @@ class SignalCli extends events_1.EventEmitter {
             };
             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 errors_1.ConnectionError('Not connected. Call connect() first.');
-        }
         const id = (0, uuid_1.v4)();
         const request = {
             jsonrpc: '2.0',
@@ -408,203 +478,113 @@ class SignalCli extends events_1.EventEmitter {
             params,
             id,
         };
-        const promise = new Promise((resolve, reject) => {
-            this.requestPromises.set(id, { resolve, reject });
+        const executeRequest = () => {
+            // 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 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 errors_1.ConnectionError('Not connected. Call connect() first.');
+            }
+            const promise = new Promise((resolve, reject) => {
+                this.requestPromises.set(id, { resolve, reject });
+            });
+            this.cliProcess.stdin.write(JSON.stringify(request) + '\n');
+            return promise;
+        };
+        // Standardized timeout for all RPC requests
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                this.requestPromises.delete(id);
+                reject(new errors_1.ConnectionError(`RPC request timeout: ${method} (${this.config.requestTimeout}ms)`));
+            }, this.config.requestTimeout);
         });
-        this.cliProcess.stdin.write(JSON.stringify(request) + '\n');
-        return promise;
+        return Promise.race([executeRequest(), timeoutPromise]);
     }
     isGroupId(recipient) {
-        return recipient.includes('=') || recipient.includes('/') || (recipient.includes('+') && !recipient.startsWith('+'));
+        return (recipient.includes('=') ||
+            recipient.includes('/') ||
+            (recipient.includes('+') && !recipient.startsWith('+')));
     }
     // ############# Refactored Methods #############
     async register(number, voice, captcha) {
-        await this.sendJsonRpcRequest('register', { account: number, voice, captcha });
+        return this.accounts.register(number, voice, captcha);
     }
     async verify(number, token, pin) {
-        await this.sendJsonRpcRequest('verify', { account: number, token, pin });
+        return this.accounts.verify(number, token, pin);
     }
     async sendMessage(recipient, message, options = {}) {
-        const params = {
-            message,
-            account: this.account
-        };
-        // Add recipient information
-        if (this.isGroupId(recipient)) {
-            params.groupId = recipient;
-        }
-        else {
-            params.recipients = [recipient];
-        }
-        // Add well-known options
-        if (options.attachments && options.attachments.length > 0) {
-            params.attachments = options.attachments;
-        }
-        if (options.expiresInSeconds) {
-            params.expiresInSeconds = options.expiresInSeconds;
-        }
-        if (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);
-    }
-    async sendReaction(recipient, targetAuthor, targetTimestamp, emoji, remove = false) {
-        const params = {
-            emoji,
-            targetAuthor,
-            targetTimestamp,
-            remove,
-            account: this.account
-        };
-        if (this.isGroupId(recipient)) {
-            params.groupId = recipient;
-        }
-        else {
-            params.recipients = [recipient];
-        }
-        return this.sendJsonRpcRequest('sendReaction', params);
+        return this.messages.sendMessage(recipient, message, options);
+    }
+    async sendReaction(recipient, targetAuthor, targetTimestamp, emoji, remove = false, isStory = false) {
+        return this.messages.sendReaction(recipient, targetAuthor, targetTimestamp, emoji, remove, isStory);
     }
     async sendTyping(recipient, stop = false) {
-        const params = { when: !stop, account: this.account };
-        if (this.isGroupId(recipient)) {
-            params.groupId = recipient;
-        }
-        else {
-            params.recipients = [recipient];
-        }
-        await this.sendJsonRpcRequest('sendTyping', params);
+        return this.messages.sendTyping(recipient, stop);
     }
     async remoteDeleteMessage(recipient, targetTimestamp) {
-        const params = { targetTimestamp, account: this.account };
-        if (this.isGroupId(recipient)) {
-            params.groupId = recipient;
-        }
-        else {
-            params.recipients = [recipient];
-        }
-        await this.sendJsonRpcRequest('remoteDelete', params);
+        return this.messages.remoteDeleteMessage(recipient, targetTimestamp);
     }
     async updateContact(number, name, options = {}) {
-        await this.sendJsonRpcRequest('updateContact', { account: this.account, recipient: number, name, ...options });
+        return this.contacts.updateContact(number, name, options);
     }
     async block(recipients, groupId) {
-        await this.sendJsonRpcRequest('block', { account: this.account, recipient: recipients, groupId });
+        return this.contacts.block(recipients, groupId);
     }
     async unblock(recipients, groupId) {
-        await this.sendJsonRpcRequest('unblock', { account: this.account, recipient: recipients, groupId });
+        return this.contacts.unblock(recipients, groupId);
     }
     async quitGroup(groupId) {
-        await this.sendJsonRpcRequest('quitGroup', { account: this.account, groupId });
+        return this.groups.quitGroup(groupId);
     }
     async joinGroup(uri) {
-        await this.sendJsonRpcRequest('joinGroup', { account: this.account, uri });
+        return this.groups.joinGroup(uri);
     }
-    async updateProfile(name, about, aboutEmoji, avatar) {
-        await this.sendJsonRpcRequest('updateProfile', { account: this.account, name, about, aboutEmoji, avatar });
+    async updateProfile(name, about, aboutEmoji, avatar, options = {}) {
+        return this.accounts.updateProfile(name, about, aboutEmoji, avatar, options);
     }
     async sendReceipt(recipient, targetTimestamp, type = 'read') {
-        await this.sendJsonRpcRequest('sendReceipt', { account: this.account, recipient, targetTimestamp, type });
+        return this.messages.sendReceipt(recipient, targetTimestamp, type);
     }
     async listStickerPacks() {
-        return this.sendJsonRpcRequest('listStickerPacks', { account: this.account });
+        return this.stickers.listStickerPacks();
     }
     async addStickerPack(packId, packKey) {
-        await this.sendJsonRpcRequest('addStickerPack', { account: this.account, packId, packKey });
+        return this.stickers.addStickerPack(packId, packKey);
     }
     async unregister() {
-        await this.sendJsonRpcRequest('unregister', { account: this.account });
+        return this.accounts.unregister();
     }
     async deleteLocalAccountData() {
-        await this.sendJsonRpcRequest('deleteLocalAccountData', { account: this.account });
+        return this.accounts.deleteLocalAccountData();
     }
     async updateAccountConfiguration(config) {
-        await this.sendJsonRpcRequest('updateConfiguration', { account: this.account, ...config });
+        return this.accounts.updateAccountConfiguration(config);
     }
     async removeDevice(deviceId) {
-        await this.sendJsonRpcRequest('removeDevice', { account: this.account, deviceId });
+        return this.devices.removeDevice(deviceId);
     }
     async setPin(pin) {
-        await this.sendJsonRpcRequest('setPin', { account: this.account, pin });
+        return this.accounts.setPin(pin);
     }
     async removePin() {
-        await this.sendJsonRpcRequest('removePin', { account: this.account });
+        return this.accounts.removePin();
     }
     async listIdentities(number) {
-        return this.sendJsonRpcRequest('listIdentities', { account: this.account, number });
+        return this.contacts.listIdentities(number);
     }
     async trustIdentity(number, safetyNumber, verified = true) {
-        await this.sendJsonRpcRequest('trust', { account: this.account, recipient: number, safetyNumber, verified });
+        return this.contacts.trustIdentity(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) {
@@ -612,30 +592,11 @@ class SignalCli extends events_1.EventEmitter {
         }
         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) {
@@ -644,24 +605,9 @@ class SignalCli extends events_1.EventEmitter {
         }
         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' ||
+        return allIdentities.filter((identity) => identity.trustLevel === 'UNTRUSTED' ||
             identity.trustLevel === 'TRUST_ON_FIRST_USE' ||
             !identity.trustLevel);
     }
@@ -669,216 +615,63 @@ class SignalCli extends events_1.EventEmitter {
         const result = await this.sendJsonRpcRequest('link', { deviceName });
         return result.uri;
     }
-    /**
-     * Link a new device to an existing Signal account with QR code support.
-     * This method provides a complete device linking solution with QR code generation.
-     *
-     * @param options - Linking options including device name and QR code output preferences
-     * @returns Promise resolving to LinkingResult with QR code data and linking status
-     */
     async deviceLink(options = {}) {
-        const { spawn } = await Promise.resolve().then(() => __importStar(require('child_process')));
-        return new Promise((resolve, reject) => {
-            const deviceName = options.name || 'Signal SDK Device';
-            // Spawn signal-cli link command
-            let linkProcess;
-            if (process.platform === 'win32') {
-                // On Windows, use cmd.exe to run the batch file with proper quoting for paths with spaces
-                linkProcess = spawn('cmd.exe', ['/c', `"${this.signalCliPath}"`, 'link', '--name', deviceName], {
-                    stdio: ['pipe', 'pipe', 'pipe']
-                });
-            }
-            else {
-                linkProcess = spawn(this.signalCliPath, ['link', '--name', deviceName], {
-                    stdio: ['pipe', 'pipe', 'pipe']
-                });
-            }
-            let qrCodeData;
-            let linkingComplete = false;
-            let hasError = false;
-            // Handle stdout (where QR code URI will be)
-            linkProcess.stdout.on('data', (data) => {
-                const output = data.toString('utf8').trim();
-                // Look for QR code URI (starts with sgnl://)
-                if (output.includes('sgnl://')) {
-                    const uriMatch = output.match(/sgnl:\/\/[^\s]+/);
-                    if (uriMatch && !qrCodeData) {
-                        const uri = uriMatch[0];
-                        qrCodeData = {
-                            uri
-                        };
-                        // Auto-display QR code if requested
-                        if (options.qrCodeOutput === 'console') {
-                            console.log('\n- QR CODE - SCAN WITH YOUR PHONE:');
-                            console.log('===================================');
-                            this.displayQRCode(uri);
-                            console.log('===================================\n');
-                        }
-                    }
-                }
-                // Check for successful linking
-                if (output.includes('Device registered') || output.includes('Successfully linked')) {
-                    linkingComplete = true;
-                }
-            });
-            // Handle stderr for errors
-            linkProcess.stderr.on('data', (data) => {
-                const error = data.toString('utf8').trim();
-                // Filter out informational messages
-                if (!error.includes('INFO') && !error.includes('DEBUG') && error.length > 0) {
-                    hasError = true;
-                }
-            });
-            // Handle process exit
-            linkProcess.on('close', (code) => {
-                if (code === 0 && linkingComplete) {
-                    resolve({
-                        success: true,
-                        isLinked: true,
-                        deviceName,
-                        qrCode: qrCodeData
-                    });
-                }
-                else if (code === 0 && qrCodeData) {
-                    resolve({
-                        success: true,
-                        isLinked: false,
-                        deviceName,
-                        qrCode: qrCodeData
-                    });
-                }
-                else {
-                    resolve({
-                        success: false,
-                        error: hasError ? 'Device linking failed' : `signal-cli exited with code ${code}`,
-                        qrCode: qrCodeData
-                    });
-                }
-            });
-            // Handle process errors
-            linkProcess.on('error', (error) => {
-                reject(new Error(`Failed to start device linking: ${error.message}`));
-            });
-        });
+        return this.devices.deviceLink(options);
     }
-    /**
-     * Display ASCII QR code in console.
-     * Uses qrcode-terminal which is included as a dependency.
-     */
     displayQRCode(uri) {
         qrcodeTerminal.generate(uri, { small: true });
     }
     async addDevice(uri, deviceName) {
-        await this.sendJsonRpcRequest('addDevice', { account: this.account, uri, deviceName });
+        return this.devices.addDevice(uri, deviceName);
     }
     async sendSyncRequest() {
         await this.sendJsonRpcRequest('sendSyncRequest', { account: this.account });
     }
     async sendMessageRequestResponse(recipient, response) {
-        await this.sendJsonRpcRequest('sendMessageRequestResponse', { account: this.account, recipient, type: response });
+        await this.sendJsonRpcRequest('sendMessageRequestResponse', {
+            account: this.account,
+            recipient,
+            type: response,
+        });
     }
     async getVersion() {
         return this.sendJsonRpcRequest('version');
     }
     async createGroup(name, members) {
-        return this.sendJsonRpcRequest('updateGroup', { account: this.account, name, members });
+        return this.groups.createGroup(name, members);
     }
     async updateGroup(groupId, options) {
-        const params = { groupId, account: this.account };
-        if (options.name)
-            params.name = options.name;
-        if (options.description)
-            params.description = options.description;
-        if (options.avatar)
-            params.avatar = options.avatar;
-        if (options.addMembers)
-            params.addMembers = options.addMembers;
-        if (options.removeMembers)
-            params.removeMembers = options.removeMembers;
-        if (options.promoteAdmins)
-            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)
-            params.permissionAddMember = options.permissionAddMember;
-        if (options.permissionEditDetails)
-            params.permissionEditDetails = options.permissionEditDetails;
-        if (options.permissionSendMessage)
-            params.permissionSendMessage = options.permissionSendMessage;
-        if (options.expirationTimer)
-            params.expiration = options.expirationTimer;
-        await this.sendJsonRpcRequest('updateGroup', params);
+        return this.groups.updateGroup(groupId, options);
     }
     async listGroups() {
-        return this.sendJsonRpcRequest('listGroups', { account: this.account });
+        return this.groups.listGroups();
     }
-    /**
-     * 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 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 });
+        return this.contacts.listContacts();
     }
     async listDevices() {
-        return this.sendJsonRpcRequest('listDevices', { account: this.account });
+        return this.devices.listDevices();
+    }
+    async updateDevice(options) {
+        return this.devices.updateDevice(options);
     }
     async listAccounts() {
-        const result = await this.sendJsonRpcRequest('listAccounts');
-        return result.accounts.map((acc) => acc.number);
+        return this.accounts.listAccounts();
     }
     // ############# Deprecated Methods (Kept for backward compatibility) #############
     /**
@@ -888,8 +681,8 @@ class SignalCli extends events_1.EventEmitter {
     async receiveMessages() {
         console.warn("receiveMessages is deprecated and will be removed in a future version. Use connect() and listen for 'message' events instead.");
         // Return empty array but log helpful migration info
-        console.info("Migration guide: Replace receiveMessages() with:");
-        console.info("  await signalCli.connect();");
+        console.info('Migration guide: Replace receiveMessages() with:');
+        console.info('  await signalCli.connect();');
         console.info("  signalCli.on('message', (msg) => { /* handle message */ });");
         return Promise.resolve([]);
     }
@@ -898,7 +691,7 @@ class SignalCli extends events_1.EventEmitter {
      * This method now calls connect() for backward compatibility.
      */
     startDaemon() {
-        console.warn("startDaemon is deprecated. Use connect() instead.");
+        console.warn('startDaemon is deprecated. Use connect() instead.');
         this.connect();
     }
     /**
@@ -906,7 +699,7 @@ class SignalCli extends events_1.EventEmitter {
      * This method now calls gracefulShutdown() for backward compatibility.
      */
     stopDaemon() {
-        console.warn("stopDaemon is deprecated. Use gracefulShutdown() or disconnect() instead.");
+        console.warn('stopDaemon is deprecated. Use gracefulShutdown() or disconnect() instead.');
         this.gracefulShutdown();
     }
     // ############# MESSAGE RECEIVING #############
@@ -932,634 +725,96 @@ class SignalCli extends events_1.EventEmitter {
      * ```
      */
     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;
-        }
+        return this.messages.receive(options);
     }
-    /**
-     * 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;
+        // Kept for backward compatibility if needed internally, but should use MessageManager.parseEnvelope
+        return this.messages.parseEnvelope(envelope);
     }
-    // ############# NEW FEATURES - Missing signal-cli Commands #############
-    /**
-     * Remove a contact from the contact list.
-     * @param number - The phone number of the contact to remove
-     * @param options - Options for how to remove the contact
-     */
     async removeContact(number, options = {}) {
-        const params = {
-            account: this.account,
-            recipient: number
-        };
-        if (options.hide)
-            params.hide = true;
-        if (options.forget)
-            params.forget = true;
-        await this.sendJsonRpcRequest('removeContact', params);
+        return this.contacts.removeContact(number, options);
     }
-    /**
-     * Check if phone numbers are registered with Signal.
-     * @param numbers - Array of phone numbers to check
-     * @param usernames - Optional array of usernames to check
-     * @returns Array of user status results
-     */
     async getUserStatus(numbers = [], usernames = []) {
-        const params = { account: this.account };
-        if (numbers.length > 0)
-            params.recipients = numbers;
-        if (usernames.length > 0)
-            params.usernames = usernames;
-        const result = await this.sendJsonRpcRequest('getUserStatus', params);
-        // Transform the result to match our interface
-        const statusResults = [];
-        if (result.recipients) {
-            result.recipients.forEach((recipient) => {
-                statusResults.push({
-                    number: recipient.number,
-                    isRegistered: recipient.isRegistered || false,
-                    uuid: recipient.uuid,
-                    username: recipient.username
-                });
-            });
-        }
-        return statusResults;
+        return this.contacts.getUserStatus(numbers, usernames);
     }
-    /**
-     * 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
-        };
-        if (paymentData.note) {
-            params.note = paymentData.note;
-        }
-        if (this.isGroupId(recipient)) {
-            params.groupId = recipient;
-        }
-        else {
-            params.recipient = recipient;
-        }
-        return this.sendJsonRpcRequest('sendPaymentNotification', params);
+        return this.accounts.sendPaymentNotification(recipient, paymentData);
     }
-    /**
-     * Upload a custom sticker pack to Signal.
-     * @param manifest - Sticker pack manifest information
-     * @returns Upload result with pack ID and key
-     */
     async uploadStickerPack(manifest) {
-        const params = {
-            account: this.account,
-            path: manifest.path
-        };
-        const result = await this.sendJsonRpcRequest('uploadStickerPack', params);
-        return {
-            packId: result.packId,
-            packKey: result.packKey,
-            installUrl: result.installUrl
-        };
+        return this.stickers.uploadStickerPack(manifest);
     }
-    /**
-     * Submit a rate limit challenge to lift rate limiting.
-     * @param challenge - Challenge token from the proof required error
-     * @param captcha - Captcha token from solved captcha
-     * @returns Challenge result indicating success/failure
-     */
     async submitRateLimitChallenge(challenge, captcha) {
-        const params = {
-            account: this.account,
-            challenge,
-            captcha
-        };
-        const result = await this.sendJsonRpcRequest('submitRateLimitChallenge', params);
-        return {
-            success: result.success || false,
-            retryAfter: result.retryAfter,
-            message: result.message
-        };
+        return this.accounts.submitRateLimitChallenge(challenge, captcha);
     }
-    /**
-     * 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,
-            voice
-        };
-        if (captcha)
-            params.captcha = captcha;
-        await this.sendJsonRpcRequest('startChangeNumber', params);
+        return this.accounts.startChangeNumber(newNumber, voice, captcha);
     }
-    /**
-     * 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(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,
-            number: newNumber,
-            verificationCode
-        };
-        if (pin)
-            params.pin = pin;
-        await this.sendJsonRpcRequest('finishChangeNumber', params);
+        return this.accounts.finishChangeNumber(newNumber, verificationCode, pin);
     }
-    /**
-     * Enhanced send message with progress callback support.
-     * @param recipient - Phone number or group ID
-     * @param message - Message text
-     * @param options - Send options including progress callback
-     * @returns Send response
-     */
     async sendMessageWithProgress(recipient, message, options = {}) {
-        // For now, this is the same as sendMessage since signal-cli doesn't provide
-        // native progress callbacks. This is a placeholder for future enhancement.
-        const { onProgress, ...sendOptions } = options;
-        // Simulate progress for large attachments
-        if (onProgress && sendOptions.attachments && sendOptions.attachments.length > 0) {
-            // Simulate upload progress
-            for (let i = 0; i <= 100; i += 10) {
-                onProgress({
-                    total: 100,
-                    uploaded: i,
-                    percentage: i
-                });
-                // Small delay to simulate upload
-                await new Promise(resolve => setTimeout(resolve, 50));
-            }
-        }
-        return this.sendMessage(recipient, message, sendOptions);
+        return this.messages.sendMessageWithProgress(recipient, message, options);
     }
-    // ========== 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);
+        return this.messages.sendPollCreate(options);
     }
-    /**
-     * 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);
+        return this.messages.sendPollVote(recipient, options);
     }
-    /**
-     * 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);
+        return this.messages.sendPollTerminate(recipient, options);
     }
-    /**
-     * 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'
-            };
-        }
+        return this.accounts.updateAccount(options);
     }
-    /**
-     * 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 });
+        return this.accounts.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 });
+        return this.accounts.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;
+        return this.messages.getAttachment(options);
     }
-    /**
-     * 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;
+        return this.contacts.getAvatar(options);
     }
-    /**
-     * 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;
+        return this.stickers.getSticker(options);
     }
-    /**
-     * 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) {
+        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);
+        return this.groups.listGroupsDetailed(options);
     }
-    /**
-     * 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 || [];
+        return this.accounts.listAccountsDetailed();
     }
-    /**
-     * 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),
-        };
+        return this.contacts.parseContactProfile(contact);
     }
-    /**
-     * 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 || [],
-        };
+        return this.groups.parseGroupDetails(group);
     }
-    /**
-     * 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));
+        return this.contacts.getContactsWithProfiles();
     }
-    /**
-     * 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));
+        return this.groups.getGroupsWithDetails(options);
+    }
+    async isRegistered(number) {
+        const results = await this.getUserStatus([number]);
+        return results.length > 0 && results[0].isRegistered;
+    }
+    async sendNoteToSelf(message, options = {}) {
+        if (!this.account) {
+            throw new Error('Account must be configured to send Note to Self');
+        }
+        return this.sendMessage(this.account, message, { ...options, noteToSelf: true });
     }
 }
 exports.SignalCli = SignalCli;