signal-sdk 0.0.9 → 0.1.0

package/dist/SignalCli.js

@@ -39,11 +39,27 @@ const uuid_1 = require("uuid");
 const qrcodeTerminal = __importStar(require("qrcode-terminal"));
 const events_1 = require("events");
 const path = __importStar(require("path"));
+const validators_1 = require("./validators");
+const retry_1 = require("./retry");
+const config_1 = require("./config");
+const errors_1 = require("./errors");
 class SignalCli extends events_1.EventEmitter {
-    constructor(accountOrPath, account) {
+    constructor(accountOrPath, account, config = {}) {
         super();
         this.cliProcess = null;
         this.requestPromises = new Map();
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        // Validate and merge configuration
+        this.config = (0, config_1.validateConfig)(config);
+        // Initialize logger
+        this.logger = new config_1.Logger({
+            level: this.config.verbose ? 'debug' : 'info',
+            enableFile: !!this.config.logFile,
+            filePath: this.config.logFile
+        });
+        // Initialize rate limiter
+        this.rateLimiter = new retry_1.RateLimiter(this.config.maxConcurrentRequests, this.config.minRequestInterval);
         let signalCliPath;
         let phoneNumber;
         // Smart parameter detection
@@ -707,5 +723,245 @@ class SignalCli extends events_1.EventEmitter {
         }
         return this.sendMessage(recipient, message, sendOptions);
     }
+    // ========== NEW METHODS FOR 100% signal-cli COMPATIBILITY ==========
+    /**
+     * Send a poll create message to a recipient or group.
+     * @param options Poll creation options
+     * @returns Send response with timestamp
+     */
+    async sendPollCreate(options) {
+        this.logger.debug('Sending poll create', options);
+        (0, validators_1.validateMessage)(options.question, 500);
+        if (!options.options || options.options.length < 2) {
+            throw new errors_1.MessageError('Poll must have at least 2 options');
+        }
+        if (options.options.length > 10) {
+            throw new errors_1.MessageError('Poll cannot have more than 10 options');
+        }
+        const params = {
+            question: options.question,
+            options: options.options,
+            account: this.account
+        };
+        if (options.multiSelect !== undefined) {
+            params.multiSelect = options.multiSelect;
+        }
+        if (options.groupId) {
+            (0, validators_1.validateGroupId)(options.groupId);
+            params.groupId = options.groupId;
+        }
+        else if (options.recipients) {
+            params.recipients = options.recipients.map(r => {
+                (0, validators_1.validateRecipient)(r);
+                return r;
+            });
+        }
+        else {
+            throw new errors_1.MessageError('Must specify either recipients or groupId');
+        }
+        return this.sendJsonRpcRequest('sendPollCreate', params);
+    }
+    /**
+     * Send a poll vote message to vote on a poll.
+     * @param recipient Recipient or group ID
+     * @param options Poll vote options
+     * @returns Send response with timestamp
+     */
+    async sendPollVote(recipient, options) {
+        this.logger.debug('Sending poll vote', { recipient, options });
+        (0, validators_1.validateRecipient)(options.pollAuthor);
+        (0, validators_1.validateTimestamp)(options.pollTimestamp);
+        if (!options.optionIndexes || options.optionIndexes.length === 0) {
+            throw new errors_1.MessageError('Must specify at least one option to vote for');
+        }
+        const params = {
+            pollAuthor: options.pollAuthor,
+            pollTimestamp: options.pollTimestamp,
+            options: options.optionIndexes,
+            account: this.account
+        };
+        if (options.voteCount !== undefined) {
+            params.voteCount = options.voteCount;
+        }
+        if (this.isGroupId(recipient)) {
+            (0, validators_1.validateGroupId)(recipient);
+            params.groupId = recipient;
+        }
+        else {
+            (0, validators_1.validateRecipient)(recipient);
+            params.recipient = recipient;
+        }
+        return this.sendJsonRpcRequest('sendPollVote', params);
+    }
+    /**
+     * Send a poll terminate message to close a poll.
+     * @param recipient Recipient or group ID
+     * @param options Poll terminate options
+     * @returns Send response with timestamp
+     */
+    async sendPollTerminate(recipient, options) {
+        this.logger.debug('Sending poll terminate', { recipient, options });
+        (0, validators_1.validateTimestamp)(options.pollTimestamp);
+        const params = {
+            pollTimestamp: options.pollTimestamp,
+            account: this.account
+        };
+        if (this.isGroupId(recipient)) {
+            (0, validators_1.validateGroupId)(recipient);
+            params.groupId = recipient;
+        }
+        else {
+            (0, validators_1.validateRecipient)(recipient);
+            params.recipient = recipient;
+        }
+        return this.sendJsonRpcRequest('sendPollTerminate', params);
+    }
+    /**
+     * Update account information (device name, username, privacy settings).
+     * @param options Account update options
+     * @returns Account update result
+     */
+    async updateAccount(options) {
+        this.logger.debug('Updating account', options);
+        const params = { account: this.account };
+        if (options.deviceName) {
+            params.deviceName = options.deviceName;
+        }
+        if (options.username) {
+            params.username = options.username;
+        }
+        if (options.deleteUsername) {
+            params.deleteUsername = true;
+        }
+        if (options.unrestrictedUnidentifiedSender !== undefined) {
+            params.unrestrictedUnidentifiedSender = options.unrestrictedUnidentifiedSender;
+        }
+        if (options.discoverableByNumber !== undefined) {
+            params.discoverableByNumber = options.discoverableByNumber;
+        }
+        if (options.numberSharing !== undefined) {
+            params.numberSharing = options.numberSharing;
+        }
+        try {
+            const result = await this.sendJsonRpcRequest('updateAccount', params);
+            return {
+                success: true,
+                username: result.username,
+                usernameLink: result.usernameLink
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Get raw attachment data as base64 string.
+     * @param options Attachment retrieval options
+     * @returns Base64 encoded attachment data
+     */
+    async getAttachment(options) {
+        this.logger.debug('Getting attachment', options);
+        if (!options.id) {
+            throw new errors_1.MessageError('Attachment ID is required');
+        }
+        const params = {
+            id: options.id,
+            account: this.account
+        };
+        if (options.groupId) {
+            (0, validators_1.validateGroupId)(options.groupId);
+            params.groupId = options.groupId;
+        }
+        else if (options.recipient) {
+            (0, validators_1.validateRecipient)(options.recipient);
+            params.recipient = options.recipient;
+        }
+        const result = await this.sendJsonRpcRequest('getAttachment', params);
+        return result.data || result;
+    }
+    /**
+     * Get raw avatar data as base64 string.
+     * @param options Avatar retrieval options
+     * @returns Base64 encoded avatar data
+     */
+    async getAvatar(options) {
+        this.logger.debug('Getting avatar', options);
+        const params = { account: this.account };
+        if (options.contact) {
+            (0, validators_1.validateRecipient)(options.contact);
+            params.contact = options.contact;
+        }
+        else if (options.profile) {
+            (0, validators_1.validateRecipient)(options.profile);
+            params.profile = options.profile;
+        }
+        else if (options.groupId) {
+            (0, validators_1.validateGroupId)(options.groupId);
+            params.groupId = options.groupId;
+        }
+        else {
+            throw new errors_1.MessageError('Must specify contact, profile, or groupId');
+        }
+        const result = await this.sendJsonRpcRequest('getAvatar', params);
+        return result.data || result;
+    }
+    /**
+     * Get raw sticker data as base64 string.
+     * @param options Sticker retrieval options
+     * @returns Base64 encoded sticker data
+     */
+    async getSticker(options) {
+        this.logger.debug('Getting sticker', options);
+        if (!options.packId || !options.stickerId) {
+            throw new errors_1.MessageError('Pack ID and sticker ID are required');
+        }
+        const params = {
+            packId: options.packId,
+            stickerId: options.stickerId,
+            account: this.account
+        };
+        const result = await this.sendJsonRpcRequest('getSticker', params);
+        return result.data || result;
+    }
+    /**
+     * Send contacts synchronization message to linked devices.
+     * @param options Contacts sync options
+     */
+    async sendContacts(options = {}) {
+        this.logger.debug('Sending contacts sync');
+        const params = { account: this.account };
+        if (options.includeAllRecipients) {
+            params.allRecipients = true;
+        }
+        await this.sendJsonRpcRequest('sendContacts', params);
+    }
+    /**
+     * List groups with optional filtering and details.
+     * @param options List groups options
+     * @returns Array of group information
+     */
+    async listGroupsDetailed(options = {}) {
+        this.logger.debug('Listing groups with options', options);
+        const params = { account: this.account };
+        if (options.detailed) {
+            params.detailed = true;
+        }
+        if (options.groupIds && options.groupIds.length > 0) {
+            params.groupId = options.groupIds;
+        }
+        return this.sendJsonRpcRequest('listGroups', params);
+    }
+    /**
+     * List all local accounts.
+     * @returns Array of account phone numbers
+     */
+    async listAccountsDetailed() {
+        this.logger.debug('Listing all accounts');
+        const result = await this.sendJsonRpcRequest('listAccounts');
+        return result.accounts || [];
+    }
 }
 exports.SignalCli = SignalCli;

package/dist/__tests__/SignalBot.additional.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Additional tests for SignalBot
+ * Covers message handling, commands, and edge cases
+ */
+export {};

package/dist/__tests__/SignalBot.additional.test.js

@@ -0,0 +1,333 @@
+"use strict";
+/**
+ * Additional tests for SignalBot
+ * Covers message handling, commands, and edge cases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalBot_1 = require("../SignalBot");
+describe('SignalBot Additional Tests', () => {
+    let bot;
+    let mockConfig;
+    beforeEach(() => {
+        mockConfig = {
+            phoneNumber: '+1234567890',
+            admins: ['+0987654321'],
+            settings: {
+                commandPrefix: '/',
+                autoReact: true,
+                logMessages: true,
+                welcomeNewMembers: true,
+                cooldownSeconds: 2,
+                maxMessageLength: 1000
+            }
+        };
+    });
+    afterEach(async () => {
+        if (bot) {
+            await bot.stop();
+            // Wait for any pending async operations to complete
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    });
+    describe('Command Management', () => {
+        test('should add custom command and execute it', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const customHandler = jest.fn().mockResolvedValue('Custom response');
+            bot.addCommand({
+                name: 'custom',
+                description: 'Custom command',
+                handler: customHandler
+            });
+            const commands = bot.getCommands();
+            expect(commands.find(c => c.name === 'custom')).toBeDefined();
+        });
+        test('should remove command successfully', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            bot.addCommand({
+                name: 'temp',
+                description: 'Temporary command',
+                handler: async () => 'temp'
+            });
+            expect(bot.removeCommand('temp')).toBe(true);
+            expect(bot.removeCommand('nonexistent')).toBe(false);
+        });
+        test('should prevent duplicate commands', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            bot.addCommand({
+                name: 'test',
+                description: 'Test command',
+                handler: async () => 'test1'
+            });
+            bot.addCommand({
+                name: 'test',
+                description: 'Test command 2',
+                handler: async () => 'test2'
+            });
+            const commands = bot.getCommands();
+            const testCommands = commands.filter(c => c.name === 'test');
+            expect(testCommands.length).toBe(1);
+        });
+    });
+    describe('Admin Management', () => {
+        test('should identify admin correctly', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            expect(bot.isAdmin('+0987654321')).toBe(true);
+            expect(bot.isAdmin('+1111111111')).toBe(false);
+        });
+    });
+    describe('Statistics', () => {
+        test('should track bot statistics', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const stats = bot.getStats();
+            expect(stats).toHaveProperty('messagesReceived');
+            expect(stats).toHaveProperty('commandsExecuted');
+            expect(stats).toHaveProperty('startTime');
+            expect(stats).toHaveProperty('lastActivity');
+            expect(stats.messagesReceived).toBe(0);
+            expect(stats.commandsExecuted).toBe(0);
+        });
+    });
+    describe('Group Management', () => {
+        test('should get bot group ID', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const groupId = bot.getBotGroupId();
+            expect(groupId).toBeNull(); // Not set until bot starts
+        });
+        test('should create bot without group config', () => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890'
+            });
+            expect(bot).toBeDefined();
+            expect(bot.getBotGroupId()).toBeNull();
+        });
+        test('should create bot with group config', () => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890',
+                group: {
+                    name: 'Test Group',
+                    description: 'Test Description',
+                    createIfNotExists: true,
+                    initialMembers: ['+1111111111', '+2222222222']
+                }
+            });
+            expect(bot).toBeDefined();
+        });
+    });
+    describe('Message Sending', () => {
+        test('should queue message for sending', async () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const mockSignalCli = bot.getSignalCli();
+            const sendMessageSpy = jest.spyOn(mockSignalCli, 'sendMessage').mockResolvedValue({
+                results: [{ type: 'SUCCESS' }],
+                timestamp: Date.now()
+            });
+            await bot.sendMessage('+1111111111', 'Test message');
+            // Wait for queue to process
+            await new Promise(resolve => setTimeout(resolve, 150));
+            expect(sendMessageSpy).toHaveBeenCalledWith('+1111111111', 'Test message');
+        });
+        test('should queue reaction for sending', async () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const mockSignalCli = bot.getSignalCli();
+            const sendReactionSpy = jest.spyOn(mockSignalCli, 'sendReaction').mockResolvedValue({
+                results: [{ type: 'SUCCESS' }],
+                timestamp: Date.now()
+            });
+            await bot.sendReaction('+1111111111', '+2222222222', 123456, '👍');
+            // Wait for queue to process
+            await new Promise(resolve => setTimeout(resolve, 150));
+            expect(sendReactionSpy).toHaveBeenCalledWith('+1111111111', '+2222222222', 123456, '👍');
+        });
+        test('should handle message with attachments', async () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const mockSignalCli = bot.getSignalCli();
+            const sendMessageSpy = jest.spyOn(mockSignalCli, 'sendMessage').mockResolvedValue({
+                results: [{ type: 'SUCCESS' }],
+                timestamp: Date.now()
+            });
+            await bot.sendMessageWithAttachment('+1111111111', 'Message with files', ['file1.txt', 'file2.jpg']);
+            // Wait for queue to process
+            await new Promise(resolve => setTimeout(resolve, 150));
+            expect(sendMessageSpy).toHaveBeenCalledWith('+1111111111', 'Message with files', {
+                attachments: ['file1.txt', 'file2.jpg']
+            });
+        });
+    });
+    describe('Configuration', () => {
+        test('should use default settings when not provided', () => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890'
+            });
+            const commands = bot.getCommands();
+            expect(commands.length).toBeGreaterThan(0); // Should have default commands
+        });
+        test('should use custom command prefix', () => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890',
+                settings: {
+                    commandPrefix: '!'
+                }
+            });
+            expect(bot).toBeDefined();
+        });
+        test('should handle all settings', () => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890',
+                admins: ['+1111111111'],
+                settings: {
+                    commandPrefix: '$',
+                    autoReact: false,
+                    logMessages: false,
+                    welcomeNewMembers: false,
+                    cooldownSeconds: 5,
+                    maxMessageLength: 2000
+                }
+            });
+            expect(bot).toBeDefined();
+        });
+    });
+    describe('Signal CLI Access', () => {
+        test('should provide access to underlying SignalCli', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const signalCli = bot.getSignalCli();
+            expect(signalCli).toBeDefined();
+            expect(signalCli.connect).toBeDefined();
+            expect(signalCli.disconnect).toBeDefined();
+        });
+    });
+    describe('Bot State', () => {
+        test('should track running state', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            // Bot is not running initially
+            expect(bot.getStats().startTime).toBeDefined();
+        });
+        test('should handle stop when not running', async () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            await expect(bot.stop()).resolves.toBeUndefined();
+        });
+    });
+    describe('Image Download Feature', () => {
+        test('should have downloadImageFromUrl method', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            expect(bot.downloadImageFromUrl).toBeDefined();
+            expect(typeof bot.downloadImageFromUrl).toBe('function');
+        });
+        test('should have sendMessageWithImage method', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            expect(bot.sendMessageWithImage).toBeDefined();
+            expect(typeof bot.sendMessageWithImage).toBe('function');
+        });
+    });
+    describe('Event Emitters', () => {
+        test('should emit ready event structure', (done) => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890',
+                group: {
+                    name: 'Test Group',
+                    createIfNotExists: false
+                }
+            });
+            const mockSignalCli = bot.getSignalCli();
+            jest.spyOn(mockSignalCli, 'listDevices').mockResolvedValue([
+                { id: 1, name: 'Test Device', created: Date.now(), lastSeen: Date.now() }
+            ]);
+            jest.spyOn(mockSignalCli, 'connect').mockResolvedValue(undefined);
+            jest.spyOn(mockSignalCli, 'on').mockReturnValue(mockSignalCli);
+            bot.on('ready', () => {
+                done();
+            });
+            bot.start().catch(done);
+        });
+        test('should have stopped event', async () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const stoppedHandler = jest.fn();
+            bot.on('stopped', stoppedHandler);
+            await bot.stop();
+            expect(stoppedHandler).toHaveBeenCalled();
+        });
+    });
+    describe('Default Commands', () => {
+        test('should include help command', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const commands = bot.getCommands();
+            const helpCmd = commands.find(c => c.name === 'help');
+            expect(helpCmd).toBeDefined();
+            expect(helpCmd?.description).toBeDefined();
+        });
+        test('should include stats command', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const commands = bot.getCommands();
+            const statsCmd = commands.find(c => c.name === 'stats');
+            expect(statsCmd).toBeDefined();
+            expect(statsCmd?.description).toBeDefined();
+        });
+        test('should include ping command', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const commands = bot.getCommands();
+            const pingCmd = commands.find(c => c.name === 'ping');
+            expect(pingCmd).toBeDefined();
+            expect(pingCmd?.description).toBeDefined();
+        });
+        test('should include info command', () => {
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const commands = bot.getCommands();
+            const infoCmd = commands.find(c => c.name === 'info');
+            expect(infoCmd).toBeDefined();
+            expect(infoCmd?.description).toBeDefined();
+        });
+    });
+    describe('Group Configuration with Avatar', () => {
+        test('should handle group config with avatar URL', () => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890',
+                group: {
+                    name: 'Test Group',
+                    description: 'Test Description',
+                    createIfNotExists: true,
+                    initialMembers: ['+1111111111'],
+                    avatar: 'https://example.com/avatar.jpg'
+                }
+            });
+            expect(bot).toBeDefined();
+        });
+        test('should handle group config with local avatar path', () => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890',
+                group: {
+                    name: 'Test Group',
+                    description: 'Test Description',
+                    createIfNotExists: true,
+                    initialMembers: ['+1111111111'],
+                    avatar: '/path/to/local/avatar.jpg'
+                }
+            });
+            expect(bot).toBeDefined();
+        });
+    });
+    describe('Edge Cases', () => {
+        test('should handle empty admins list', () => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890',
+                admins: []
+            });
+            expect(bot.isAdmin('+1234567890')).toBe(false);
+        });
+        test('should handle undefined settings', () => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890',
+                settings: undefined
+            });
+            expect(bot).toBeDefined();
+        });
+        test('should handle partial settings', () => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890',
+                settings: {
+                    commandPrefix: '!'
+                    // Other settings will use defaults
+                }
+            });
+            expect(bot).toBeDefined();
+        });
+    });
+});

package/dist/__tests__/SignalCli.integration.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Integration tests for SignalCli
+ * Tests complex scenarios and edge cases
+ */
+export {};