signal-sdk 0.0.9 → 0.1.1

package/dist/__tests__/MultiAccountManager.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for MultiAccountManager
+ */
+export {};

package/dist/__tests__/MultiAccountManager.test.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Tests for MultiAccountManager
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const MultiAccountManager_1 = require("../MultiAccountManager");
+const SignalCli_1 = require("../SignalCli");
+// Mock SignalCli
+jest.mock('../SignalCli');
+describe('MultiAccountManager', () => {
+    let manager;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        manager = new MultiAccountManager_1.MultiAccountManager({
+            dataPath: '/tmp/test-data',
+            verbose: false
+        });
+    });
+    afterEach(async () => {
+        if (manager) {
+            await manager.shutdown();
+        }
+    });
+    describe('Account Management', () => {
+        it('should add an account', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            expect(instance).toBeInstanceOf(SignalCli_1.SignalCli);
+            expect(manager.hasAccount('+33123456789')).toBe(true);
+            expect(manager.getAccounts()).toContain('+33123456789');
+        });
+        it('should emit accountAdded event', async () => {
+            const spy = jest.fn();
+            manager.on('accountAdded', spy);
+            await manager.addAccount('+33123456789');
+            expect(spy).toHaveBeenCalledWith('+33123456789');
+        });
+        it('should throw error when adding duplicate account', async () => {
+            await manager.addAccount('+33123456789');
+            await expect(manager.addAccount('+33123456789')).rejects.toThrow('Account +33123456789 already exists');
+        });
+        it('should remove an account', async () => {
+            await manager.addAccount('+33123456789');
+            await manager.removeAccount('+33123456789');
+            expect(manager.hasAccount('+33123456789')).toBe(false);
+            expect(manager.getAccounts()).not.toContain('+33123456789');
+        });
+        it('should emit accountRemoved event', async () => {
+            const spy = jest.fn();
+            await manager.addAccount('+33123456789');
+            manager.on('accountRemoved', spy);
+            await manager.removeAccount('+33123456789');
+            expect(spy).toHaveBeenCalledWith('+33123456789');
+        });
+        it('should throw error when removing non-existent account', async () => {
+            await expect(manager.removeAccount('+33123456789')).rejects.toThrow('Account +33123456789 not found');
+        });
+        it('should get specific account instance', async () => {
+            await manager.addAccount('+33123456789');
+            const instance = manager.getAccount('+33123456789');
+            expect(instance).toBeInstanceOf(SignalCli_1.SignalCli);
+        });
+        it('should return undefined for non-existent account', () => {
+            const instance = manager.getAccount('+33999999999');
+            expect(instance).toBeUndefined();
+        });
+        it('should get all account numbers', async () => {
+            await manager.addAccount('+33123456789');
+            await manager.addAccount('+33987654321');
+            const accounts = manager.getAccounts();
+            expect(accounts).toHaveLength(2);
+            expect(accounts).toContain('+33123456789');
+            expect(accounts).toContain('+33987654321');
+        });
+    });
+    describe('Connection Management', () => {
+        it('should connect a specific account', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.connect = jest.fn().mockResolvedValue(undefined);
+            await manager.connect('+33123456789');
+            expect(instance.connect).toHaveBeenCalled();
+        });
+        it('should emit accountConnected event', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.connect = jest.fn().mockResolvedValue(undefined);
+            const spy = jest.fn();
+            manager.on('accountConnected', spy);
+            await manager.connect('+33123456789');
+            expect(spy).toHaveBeenCalledWith('+33123456789');
+        });
+        it('should disconnect a specific account', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.connect = jest.fn().mockResolvedValue(undefined);
+            instance.disconnect = jest.fn().mockResolvedValue(undefined);
+            await manager.connect('+33123456789');
+            await manager.disconnect('+33123456789');
+            expect(instance.disconnect).toHaveBeenCalled();
+        });
+        it('should emit accountDisconnected event', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.connect = jest.fn().mockResolvedValue(undefined);
+            instance.disconnect = jest.fn().mockResolvedValue(undefined);
+            const spy = jest.fn();
+            await manager.connect('+33123456789');
+            manager.on('accountDisconnected', spy);
+            await manager.disconnect('+33123456789');
+            expect(spy).toHaveBeenCalledWith('+33123456789');
+        });
+        it('should connect all accounts', async () => {
+            const instance1 = await manager.addAccount('+33123456789');
+            const instance2 = await manager.addAccount('+33987654321');
+            instance1.connect = jest.fn().mockResolvedValue(undefined);
+            instance2.connect = jest.fn().mockResolvedValue(undefined);
+            await manager.connectAll();
+            expect(instance1.connect).toHaveBeenCalled();
+            expect(instance2.connect).toHaveBeenCalled();
+        });
+        it('should disconnect all accounts', async () => {
+            const instance1 = await manager.addAccount('+33123456789');
+            const instance2 = await manager.addAccount('+33987654321');
+            instance1.connect = jest.fn().mockResolvedValue(undefined);
+            instance2.connect = jest.fn().mockResolvedValue(undefined);
+            instance1.disconnect = jest.fn().mockResolvedValue(undefined);
+            instance2.disconnect = jest.fn().mockResolvedValue(undefined);
+            await manager.connectAll();
+            await manager.disconnectAll();
+            expect(instance1.disconnect).toHaveBeenCalled();
+            expect(instance2.disconnect).toHaveBeenCalled();
+        });
+        it('should handle connection errors gracefully', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.connect = jest.fn().mockRejectedValue(new Error('Connection failed'));
+            await expect(manager.connect('+33123456789')).rejects.toThrow('Connection failed');
+        });
+    });
+    describe('Message Sending', () => {
+        it('should send message from specific account', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.sendMessage = jest.fn().mockResolvedValue({
+                timestamp: Date.now(),
+                results: []
+            });
+            await manager.sendMessage('+33123456789', '+33111111111', 'Hello!');
+            expect(instance.sendMessage).toHaveBeenCalledWith('+33111111111', 'Hello!', {});
+        });
+        it('should throw error when sending from non-existent account', async () => {
+            await expect(manager.sendMessage('+33999999999', '+33111111111', 'Hello!')).rejects.toThrow('Account +33999999999 not found');
+        });
+        it('should send message with options', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.sendMessage = jest.fn().mockResolvedValue({
+                timestamp: Date.now(),
+                results: []
+            });
+            const options = { attachments: ['file.jpg'] };
+            await manager.sendMessage('+33123456789', '+33111111111', 'Hello!', options);
+            expect(instance.sendMessage).toHaveBeenCalledWith('+33111111111', 'Hello!', options);
+        });
+    });
+    describe('Event Forwarding', () => {
+        it('should setup event forwarding on account addition', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            // Verify instance was created
+            expect(instance).toBeDefined();
+            expect(manager.hasAccount('+33123456789')).toBe(true);
+        });
+    });
+    describe('Status Information', () => {
+        it('should get status for specific account', async () => {
+            await manager.addAccount('+33123456789');
+            const status = manager.getStatus('+33123456789');
+            expect(status).toHaveProperty('account', '+33123456789');
+            expect(status).toHaveProperty('connected', false);
+            expect(status).toHaveProperty('lastActivity');
+            expect(status).toHaveProperty('uptime');
+        });
+        it('should return null for non-existent account status', () => {
+            const status = manager.getStatus('+33999999999');
+            expect(status).toBeNull();
+        });
+        it('should get status for all accounts', async () => {
+            await manager.addAccount('+33123456789');
+            await manager.addAccount('+33987654321');
+            const status = manager.getStatus();
+            expect(status.totalAccounts).toBe(2);
+            expect(status.connectedAccounts).toBe(0);
+            expect(status.accounts).toHaveLength(2);
+        });
+        it('should update connected count in status', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            jest.spyOn(instance, 'connect').mockResolvedValue();
+            await manager.connect('+33123456789');
+            const status = manager.getStatus();
+            expect(status.connectedAccounts).toBe(1);
+        });
+    });
+    describe('Shutdown', () => {
+        it('should shutdown and cleanup all accounts', async () => {
+            const instance1 = await manager.addAccount('+33123456789');
+            const instance2 = await manager.addAccount('+33987654321');
+            instance1.connect = jest.fn().mockResolvedValue(undefined);
+            instance2.connect = jest.fn().mockResolvedValue(undefined);
+            instance1.disconnect = jest.fn().mockResolvedValue(undefined);
+            instance2.disconnect = jest.fn().mockResolvedValue(undefined);
+            await manager.connectAll();
+            await manager.shutdown();
+            expect(manager.getAccounts()).toHaveLength(0);
+        });
+    });
+});

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,353 @@
+"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(() => {
+        // Use real timers for these tests
+        jest.useRealTimers();
+        mockConfig = {
+            phoneNumber: '+1234567890',
+            admins: ['+0987654321'],
+            settings: {
+                commandPrefix: '/',
+                autoReact: true,
+                logMessages: true,
+                welcomeNewMembers: true,
+                cooldownSeconds: 2,
+                maxMessageLength: 1000
+            }
+        };
+    });
+    afterEach(async () => {
+        if (bot) {
+            await bot.stop();
+            // Remove all listeners to prevent memory leaks
+            bot.removeAllListeners();
+            bot.getSignalCli().removeAllListeners();
+            // Wait a bit for any async operations to complete
+            await new Promise(resolve => process.nextTick(resolve));
+        }
+    });
+    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 () => {
+            jest.useFakeTimers();
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const mockSignalCli = bot.getSignalCli();
+            const sendMessageSpy = jest.spyOn(mockSignalCli, 'sendMessage').mockResolvedValue({
+                results: [{ type: 'SUCCESS' }],
+                timestamp: Date.now()
+            });
+            // Send message (queued)
+            const sendPromise = bot.sendMessage('+1111111111', 'Test message');
+            // Advance timers to process queue
+            jest.advanceTimersByTime(250);
+            await Promise.resolve(); // Let promises resolve
+            await sendPromise;
+            expect(sendMessageSpy).toHaveBeenCalledWith('+1111111111', 'Test message');
+            jest.useRealTimers();
+        });
+        test('should queue reaction for sending', async () => {
+            jest.useFakeTimers();
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const mockSignalCli = bot.getSignalCli();
+            const sendReactionSpy = jest.spyOn(mockSignalCli, 'sendReaction').mockResolvedValue({
+                results: [{ type: 'SUCCESS' }],
+                timestamp: Date.now()
+            });
+            // Send reaction (queued)
+            const sendPromise = bot.sendReaction('+1111111111', '+2222222222', 123456, '👍');
+            // Advance timers to process queue
+            jest.advanceTimersByTime(250);
+            await Promise.resolve();
+            await sendPromise;
+            expect(sendReactionSpy).toHaveBeenCalledWith('+1111111111', '+2222222222', 123456, '👍');
+            jest.useRealTimers();
+        });
+        test('should handle message with attachments', async () => {
+            jest.useFakeTimers();
+            bot = new SignalBot_1.SignalBot(mockConfig);
+            const mockSignalCli = bot.getSignalCli();
+            const sendMessageSpy = jest.spyOn(mockSignalCli, 'sendMessage').mockResolvedValue({
+                results: [{ type: 'SUCCESS' }],
+                timestamp: Date.now()
+            });
+            // Send message with attachment (queued)
+            const sendPromise = bot.sendMessageWithAttachment('+1111111111', 'Message with files', ['file1.txt', 'file2.jpg']);
+            // Advance timers to process queue and cleanup timer
+            jest.advanceTimersByTime(2500); // 250ms for queue + 2000ms for cleanup
+            await Promise.resolve();
+            await sendPromise;
+            expect(sendMessageSpy).toHaveBeenCalledWith('+1111111111', 'Message with files', {
+                attachments: ['file1.txt', 'file2.jpg']
+            });
+            jest.useRealTimers();
+        });
+    });
+    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__/SignalBot.test.js

@@ -17,7 +17,12 @@ describe('SignalBot', () => {
     afterEach(async () => {
         if (bot) {
             await bot.stop();
+            // Clean up all listeners
+            bot.removeAllListeners();
+            bot.getSignalCli().removeAllListeners();
         }
+        // Clear all timers
+        jest.clearAllTimers();
     });
     test('should create bot with minimal config', () => {
         bot = new SignalBot_1.SignalBot({

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

@@ -0,0 +1,5 @@
+/**
+ * Advanced Features Tests for SignalCli
+ * Tests for new features added for 100% signal-cli coverage
+ */
+export {};