signal-sdk 0.0.8 → 0.0.9

package/dist/SignalCli.js

@@ -0,0 +1,711 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalCli = void 0;
+const child_process_1 = require("child_process");
+const uuid_1 = require("uuid");
+const qrcodeTerminal = __importStar(require("qrcode-terminal"));
+const events_1 = require("events");
+const path = __importStar(require("path"));
+class SignalCli extends events_1.EventEmitter {
+    constructor(accountOrPath, account) {
+        super();
+        this.cliProcess = null;
+        this.requestPromises = new Map();
+        let signalCliPath;
+        let phoneNumber;
+        // Smart parameter detection
+        if (typeof accountOrPath === 'string') {
+            if (accountOrPath.startsWith('+')) {
+                // First parameter is a phone number
+                phoneNumber = accountOrPath;
+                signalCliPath = undefined;
+            }
+            else {
+                // First parameter is a path, second is phone number
+                signalCliPath = accountOrPath;
+                phoneNumber = account;
+            }
+        }
+        // Determine the correct signal-cli path based on platform
+        let defaultPath;
+        if (process.platform === 'win32') {
+            defaultPath = path.join(__dirname, '..', 'bin', 'signal-cli.bat');
+        }
+        else {
+            // For Unix/Linux systems, use the shell script
+            defaultPath = path.join(__dirname, '..', 'bin', 'signal-cli');
+        }
+        this.signalCliPath = signalCliPath || defaultPath;
+        this.account = phoneNumber;
+    }
+    async connect() {
+        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
+            this.cliProcess = (0, child_process_1.spawn)('cmd.exe', ['/c', `"${this.signalCliPath}"`, ...args]);
+        }
+        else {
+            this.cliProcess = (0, child_process_1.spawn)(this.signalCliPath, args);
+        }
+        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('error', (err) => this.emit('error', err));
+        return new Promise((resolve, reject) => {
+            // Set a timeout to resolve the promise even if no data is received
+            const connectTimeout = setTimeout(() => {
+                // Test if the process is still alive and responsive
+                if (this.cliProcess && !this.cliProcess.killed) {
+                    resolve();
+                }
+                else {
+                    reject(new Error('signal-cli process failed to start'));
+                }
+            }, 2000); // Wait 2 seconds max
+            // If we get data quickly, resolve immediately
+            this.cliProcess?.stdout?.once('data', () => {
+                clearTimeout(connectTimeout);
+                resolve();
+            });
+            // If there's an error, reject
+            this.cliProcess?.once('error', (err) => {
+                clearTimeout(connectTimeout);
+                reject(err);
+            });
+            // If the process exits immediately, that's an error
+            this.cliProcess?.once('close', (code) => {
+                clearTimeout(connectTimeout);
+                if (code !== 0) {
+                    reject(new Error(`signal-cli exited with code ${code}`));
+                }
+            });
+        });
+    }
+    disconnect() {
+        if (this.cliProcess) {
+            this.cliProcess.kill();
+            this.cliProcess = null;
+        }
+    }
+    async gracefulShutdown() {
+        return new Promise((resolve) => {
+            if (!this.cliProcess) {
+                resolve();
+                return;
+            }
+            // Listen for the process to close
+            this.cliProcess.once('close', () => {
+                this.cliProcess = null;
+                resolve();
+            });
+            // Send SIGTERM for graceful shutdown
+            this.cliProcess.kill('SIGTERM');
+            // Force kill after 5 seconds if it doesn't close gracefully
+            setTimeout(() => {
+                if (this.cliProcess) {
+                    this.cliProcess.kill('SIGKILL');
+                    this.cliProcess = null;
+                    resolve();
+                }
+            }, 5000);
+        });
+    }
+    handleRpcResponse(data) {
+        const lines = data.trim().split('\n');
+        for (const line of lines) {
+            if (!line)
+                continue;
+            try {
+                const response = JSON.parse(line);
+                if ('id' in response && response.id) {
+                    const promise = this.requestPromises.get(response.id);
+                    if (promise) {
+                        if (response.error) {
+                            promise.reject(new Error(`[${response.error.code}] ${response.error.message}`));
+                        }
+                        else {
+                            promise.resolve(response.result);
+                        }
+                        this.requestPromises.delete(response.id);
+                    }
+                }
+                else if ('method' in response) {
+                    this.emit('notification', response);
+                    if (response.method === 'receive') {
+                        this.emit('message', response.params);
+                    }
+                }
+            }
+            catch (error) {
+                this.emit('error', new Error(`Failed to parse JSON-RPC response: ${line}`));
+            }
+        }
+    }
+    handleStderrData(data) {
+        const message = data.trim();
+        if (!message)
+            return;
+        // Parse log level from signal-cli stderr output
+        // Format: "LEVEL  Component - Message"
+        const logLevelMatch = message.match(/^(ERROR|WARN|INFO|DEBUG)\s+/);
+        const logLevel = logLevelMatch ? logLevelMatch[1] : 'UNKNOWN';
+        // Only emit errors for actual ERROR level messages
+        // INFO, WARN, DEBUG messages are just logged without crashing
+        if (logLevel === 'ERROR') {
+            this.emit('error', new Error(`signal-cli error: ${message}`));
+        }
+        else {
+            // 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'));
+            // Only log actual warning messages, not informational ones
+            if (logLevel === 'WARN' && !isInformationalWarn) {
+                console.warn(`[signal-cli] ${message}`);
+            }
+            else if (logLevel === 'INFO' || logLevel === 'DEBUG') {
+                // Silently ignore INFO and DEBUG messages to avoid spam
+                // Uncomment the line below if you want to see all signal-cli logs:
+                // console.log(`[signal-cli] ${message}`);
+            }
+            else if (logLevel === 'UNKNOWN') {
+                // Unknown format, log as warning only if it doesn't look informational
+                if (!message.includes('Daemon closed') && !message.includes('gracefully')) {
+                    console.warn(`[signal-cli] ${message}`);
+                }
+            }
+        }
+    }
+    async sendJsonRpcRequest(method, params) {
+        if (!this.cliProcess || !this.cliProcess.stdin) {
+            throw new Error('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 });
+        });
+        this.cliProcess.stdin.write(JSON.stringify(request) + '\n');
+        return promise;
+    }
+    isGroupId(recipient) {
+        return recipient.includes('=') || recipient.includes('/') || (recipient.includes('+') && !recipient.startsWith('+'));
+    }
+    // ############# Refactored Methods #############
+    async register(number, voice, captcha) {
+        await this.sendJsonRpcRequest('register', { account: number, voice, captcha });
+    }
+    async verify(number, token, pin) {
+        await this.sendJsonRpcRequest('verify', { account: 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];
+        }
+        // Only add safe, well-known options to avoid JSON parsing issues
+        if (options.attachments && options.attachments.length > 0) {
+            params.attachments = options.attachments;
+        }
+        if (options.expiresInSeconds) {
+            params.expiresInSeconds = options.expiresInSeconds;
+        }
+        if (options.isViewOnce) {
+            params.isViewOnce = options.isViewOnce;
+        }
+        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);
+    }
+    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);
+    }
+    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);
+    }
+    async updateContact(number, name, options = {}) {
+        await this.sendJsonRpcRequest('updateContact', { account: this.account, recipient: number, name, ...options });
+    }
+    async block(recipients, groupId) {
+        await this.sendJsonRpcRequest('block', { account: this.account, recipient: recipients, groupId });
+    }
+    async unblock(recipients, groupId) {
+        await this.sendJsonRpcRequest('unblock', { account: this.account, recipient: recipients, groupId });
+    }
+    async quitGroup(groupId) {
+        await this.sendJsonRpcRequest('quitGroup', { account: this.account, groupId });
+    }
+    async joinGroup(uri) {
+        await this.sendJsonRpcRequest('joinGroup', { account: this.account, uri });
+    }
+    async updateProfile(name, about, aboutEmoji, avatar) {
+        await this.sendJsonRpcRequest('updateProfile', { account: this.account, name, about, aboutEmoji, avatar });
+    }
+    async sendReceipt(recipient, targetTimestamp, type = 'read') {
+        await this.sendJsonRpcRequest('sendReceipt', { account: this.account, recipient, targetTimestamp, type });
+    }
+    async listStickerPacks() {
+        return this.sendJsonRpcRequest('listStickerPacks', { account: this.account });
+    }
+    async addStickerPack(packId, packKey) {
+        await this.sendJsonRpcRequest('addStickerPack', { account: this.account, packId, packKey });
+    }
+    async unregister() {
+        await this.sendJsonRpcRequest('unregister', { account: this.account });
+    }
+    async deleteLocalAccountData() {
+        await this.sendJsonRpcRequest('deleteLocalAccountData', { account: this.account });
+    }
+    async updateAccountConfiguration(config) {
+        await this.sendJsonRpcRequest('updateConfiguration', { account: this.account, ...config });
+    }
+    async removeDevice(deviceId) {
+        await this.sendJsonRpcRequest('removeDevice', { account: this.account, deviceId });
+    }
+    async setPin(pin) {
+        await this.sendJsonRpcRequest('setPin', { account: this.account, pin });
+    }
+    async removePin() {
+        await this.sendJsonRpcRequest('removePin', { account: this.account });
+    }
+    async listIdentities(number) {
+        return this.sendJsonRpcRequest('listIdentities', { account: this.account, number });
+    }
+    async trustIdentity(number, safetyNumber, verified = true) {
+        await this.sendJsonRpcRequest('trust', { account: this.account, recipient: number, safetyNumber, verified });
+    }
+    async link(deviceName) {
+        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}`));
+            });
+        });
+    }
+    /**
+     * 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 });
+    }
+    async sendSyncRequest() {
+        await this.sendJsonRpcRequest('sendSyncRequest', { account: this.account });
+    }
+    async sendMessageRequestResponse(recipient, 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 });
+    }
+    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.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);
+    }
+    async listGroups() {
+        return this.sendJsonRpcRequest('listGroups', { account: this.account });
+    }
+    async listContacts() {
+        return this.sendJsonRpcRequest('listContacts', { account: this.account });
+    }
+    async listDevices() {
+        return this.sendJsonRpcRequest('listDevices', { account: this.account });
+    }
+    async listAccounts() {
+        const result = await this.sendJsonRpcRequest('listAccounts');
+        return result.accounts.map((acc) => acc.number);
+    }
+    // ############# Deprecated Methods (Kept for backward compatibility) #############
+    /**
+     * @deprecated Use `connect` and listen for `message` events instead.
+     * This method now provides a compatibility layer by connecting and buffering messages.
+     */
+    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("  signalCli.on('message', (msg) => { /* handle message */ });");
+        return Promise.resolve([]);
+    }
+    /**
+     * @deprecated Use `connect` instead.
+     * This method now calls connect() for backward compatibility.
+     */
+    startDaemon() {
+        console.warn("startDaemon is deprecated. Use connect() instead.");
+        this.connect();
+    }
+    /**
+     * @deprecated Use `gracefulShutdown` or `disconnect` instead.
+     * This method now calls gracefulShutdown() for backward compatibility.
+     */
+    stopDaemon() {
+        console.warn("stopDaemon is deprecated. Use gracefulShutdown() or disconnect() instead.");
+        this.gracefulShutdown();
+    }
+    // ############# 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);
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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
+     */
+    async sendPaymentNotification(recipient, paymentData) {
+        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);
+    }
+    /**
+     * 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
+        };
+    }
+    /**
+     * 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
+        };
+    }
+    /**
+     * 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
+     */
+    async startChangeNumber(newNumber, voice = false, captcha) {
+        const params = {
+            account: this.account,
+            number: newNumber,
+            voice
+        };
+        if (captcha)
+            params.captcha = captcha;
+        const result = await this.sendJsonRpcRequest('startChangeNumber', params);
+        return {
+            session: result.session,
+            newNumber,
+            challenge: result.challenge
+        };
+    }
+    /**
+     * 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
+     */
+    async finishChangeNumber(verificationCode, pin) {
+        const params = {
+            account: this.account,
+            code: verificationCode
+        };
+        if (pin)
+            params.pin = pin;
+        await this.sendJsonRpcRequest('finishChangeNumber', params);
+    }
+    /**
+     * 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);
+    }
+}
+exports.SignalCli = SignalCli;