signal-sdk 0.0.8 → 0.1.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,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__/SignalBot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/SignalBot.test.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalBot_1 = require("../SignalBot");
+describe('SignalBot', () => {
+    let bot;
+    let mockConfig;
+    beforeEach(() => {
+        mockConfig = {
+            phoneNumber: '+1234567890',
+            admins: ['+0987654321'],
+            group: {
+                name: 'Test Bot Group',
+                createIfNotExists: false
+            }
+        };
+    });
+    afterEach(async () => {
+        if (bot) {
+            await bot.stop();
+        }
+    });
+    test('should create bot with minimal config', () => {
+        bot = new SignalBot_1.SignalBot({
+            phoneNumber: '+1234567890'
+        });
+        expect(bot).toBeDefined();
+        expect(bot.isAdmin('+1234567890')).toBe(false);
+    });
+    test('should create bot with full config', () => {
+        bot = new SignalBot_1.SignalBot(mockConfig);
+        expect(bot).toBeDefined();
+        expect(bot.isAdmin('+0987654321')).toBe(true);
+        expect(bot.getBotGroupId()).toBeNull();
+    });
+    test('should add and remove commands', () => {
+        bot = new SignalBot_1.SignalBot(mockConfig);
+        const testCommand = {
+            name: 'test',
+            description: 'Test command',
+            handler: jest.fn()
+        };
+        bot.addCommand(testCommand);
+        const commands = bot.getCommands();
+        expect(commands.some((cmd) => cmd.name === 'test')).toBe(true);
+        const removed = bot.removeCommand('test');
+        expect(removed).toBe(true);
+        const commandsAfter = bot.getCommands();
+        expect(commandsAfter.some((cmd) => cmd.name === 'test')).toBe(false);
+    });
+    test('should have default commands', () => {
+        bot = new SignalBot_1.SignalBot(mockConfig);
+        const commands = bot.getCommands();
+        const commandNames = commands.map((cmd) => cmd.name);
+        expect(commandNames).toContain('help');
+        expect(commandNames).toContain('stats');
+        expect(commandNames).toContain('ping');
+        expect(commandNames).toContain('info');
+    });
+    test('should emit ready event when started', (done) => {
+        bot = new SignalBot_1.SignalBot({
+            phoneNumber: '+1234567890',
+            group: {
+                name: 'Test Group',
+                createIfNotExists: false
+            }
+        });
+        // Mock SignalCli methods to avoid actual Signal operations
+        const mockSignalCli = bot.getSignalCli();
+        jest.spyOn(mockSignalCli, 'listDevices').mockResolvedValue([
+            { id: 1, name: 'Test Device', created: Date.now(), lastSeen: Date.now() }
+        ]);
+        jest.spyOn(mockSignalCli, 'startDaemon').mockImplementation(() => { });
+        jest.spyOn(mockSignalCli, 'connect').mockResolvedValue(undefined);
+        jest.spyOn(mockSignalCli, 'on').mockReturnValue(mockSignalCli);
+        bot.on('ready', () => {
+            expect(true).toBe(true);
+            done();
+        });
+        bot.start().catch(done);
+    });
+    test('should get stats', () => {
+        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).toHaveProperty('activeUsers');
+        expect(stats.messagesReceived).toBe(0);
+        expect(stats.commandsExecuted).toBe(0);
+        expect(stats.activeUsers).toBe(0);
+    });
+    test('should handle admin permissions', () => {
+        bot = new SignalBot_1.SignalBot({
+            phoneNumber: '+1234567890',
+            admins: ['+0987654321', '+1111111111']
+        });
+        expect(bot.isAdmin('+0987654321')).toBe(true);
+        expect(bot.isAdmin('+1111111111')).toBe(true);
+        expect(bot.isAdmin('+9999999999')).toBe(false);
+    });
+});

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

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

package/dist/__tests__/SignalCli.integration.test.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Integration tests for SignalCli
+ * Tests complex scenarios and edge cases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+const child_process_1 = require("child_process");
+jest.mock('child_process');
+describe('SignalCli Integration Tests', () => {
+    let signalCli;
+    let mockProcess;
+    beforeEach(() => {
+        mockProcess = {
+            stdout: {
+                on: jest.fn(),
+                once: jest.fn(),
+            },
+            stderr: {
+                on: jest.fn(),
+            },
+            stdin: {
+                write: jest.fn(),
+            },
+            on: jest.fn(),
+            once: jest.fn(),
+            kill: jest.fn(),
+            killed: false,
+        };
+        const spawnMock = child_process_1.spawn;
+        spawnMock.mockReturnValue(mockProcess);
+        signalCli = new SignalCli_1.SignalCli('signal-cli', '+1234567890');
+    });
+    afterEach(() => {
+        if (signalCli) {
+            signalCli.disconnect();
+        }
+    });
+    describe('Connection Lifecycle', () => {
+        it('should handle multiple connect/disconnect cycles', async () => {
+            mockProcess.stdout.once.mockImplementation((event, callback) => {
+                if (event === 'data')
+                    callback();
+            });
+            await signalCli.connect();
+            signalCli.disconnect();
+            await signalCli.connect();
+            signalCli.disconnect();
+            expect(mockProcess.kill).toHaveBeenCalledTimes(2);
+        });
+        it('should handle graceful shutdown timeout', async () => {
+            mockProcess.stdout.once.mockImplementation((event, callback) => {
+                if (event === 'data')
+                    callback();
+            });
+            await signalCli.connect();
+            // Don't emit close event to simulate hanging process
+            let closeCallback;
+            mockProcess.once.mockImplementation((event, callback) => {
+                if (event === 'close') {
+                    closeCallback = callback;
+                }
+            });
+            const shutdownPromise = signalCli.gracefulShutdown();
+            // Simulate timeout and force kill
+            setTimeout(() => {
+                if (closeCallback)
+                    closeCallback(0);
+            }, 100);
+            await expect(shutdownPromise).resolves.toBeUndefined();
+        }, 10000); // Increase timeout to 10 seconds
+        it('should handle stderr data with different log levels', async () => {
+            const handleStderrData = signalCli.handleStderrData.bind(signalCli);
+            const errorHandler = jest.fn();
+            const logHandler = jest.fn();
+            signalCli.on('error', errorHandler);
+            signalCli.on('log', logHandler);
+            handleStderrData('ERROR  Component - Critical error');
+            expect(errorHandler).toHaveBeenCalled();
+            handleStderrData('WARN   Component - Warning message');
+            expect(logHandler).toHaveBeenCalledWith(expect.objectContaining({ level: 'warn' }));
+            handleStderrData('INFO   Component - Info message');
+            expect(logHandler).toHaveBeenCalledWith(expect.objectContaining({ level: 'info' }));
+            handleStderrData('DEBUG  Component - Debug message');
+            expect(logHandler).toHaveBeenCalledWith(expect.objectContaining({ level: 'debug' }));
+        });
+        it('should filter out informational WARN messages', async () => {
+            const handleStderrData = signalCli.handleStderrData.bind(signalCli);
+            const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+            handleStderrData('WARN   Component - Failed to get sender certificate');
+            handleStderrData('WARN   Component - ignoring: java.lang.InterruptedException');
+            handleStderrData('WARN   Component - Request was interrupted');
+            expect(consoleSpy).not.toHaveBeenCalled();
+            handleStderrData('WARN   Component - Real warning message');
+            expect(consoleSpy).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('JSON-RPC Response Handling', () => {
+        it('should handle multi-line JSON-RPC responses', () => {
+            const handleRpcResponse = signalCli.handleRpcResponse.bind(signalCli);
+            const mockPromise = {
+                resolve: jest.fn(),
+                reject: jest.fn(),
+            };
+            signalCli.requestPromises.set('test-id', mockPromise);
+            const multiLineData = `{"jsonrpc":"2.0","id":"test-id","result":{"success":true}}\n{"jsonrpc":"2.0","method":"receive","params":{"data":"test"}}`;
+            handleRpcResponse(multiLineData);
+            expect(mockPromise.resolve).toHaveBeenCalledWith({ success: true });
+        });
+        it('should handle malformed JSON gracefully', () => {
+            const handleRpcResponse = signalCli.handleRpcResponse.bind(signalCli);
+            const errorHandler = jest.fn();
+            signalCli.on('error', errorHandler);
+            handleRpcResponse('not valid json');
+            expect(errorHandler).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('Failed to parse JSON-RPC response')
+            }));
+        });
+        it('should emit notifications correctly', () => {
+            const handleRpcResponse = signalCli.handleRpcResponse.bind(signalCli);
+            const notificationHandler = jest.fn();
+            const messageHandler = jest.fn();
+            signalCli.on('notification', notificationHandler);
+            signalCli.on('message', messageHandler);
+            const notification = '{"jsonrpc":"2.0","method":"receive","params":{"envelope":{"dataMessage":"test"}}}';
+            handleRpcResponse(notification);
+            expect(notificationHandler).toHaveBeenCalled();
+            expect(messageHandler).toHaveBeenCalled();
+        });
+    });
+    describe('Validation Edge Cases', () => {
+        it('should validate recipients (phone, UUID, username)', async () => {
+            // Connect first
+            mockProcess.stdout.once.mockImplementation((event, callback) => {
+                if (event === 'data')
+                    callback();
+            });
+            await signalCli.connect();
+            jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
+            // Valid phone
+            await expect(signalCli.sendMessage('+1234567890', 'test')).resolves.toBeDefined();
+            // Valid UUID
+            await expect(signalCli.sendMessage('12345678-1234-1234-1234-123456789012', 'test')).resolves.toBeDefined();
+            // Valid username
+            await expect(signalCli.sendMessage('u:username.123', 'test')).resolves.toBeDefined();
+        });
+    });
+    describe('Group Detection', () => {
+        it('should correctly identify group IDs', () => {
+            const isGroupId = signalCli.isGroupId.bind(signalCli);
+            expect(isGroupId('base64groupid==')).toBe(true);
+            expect(isGroupId('group/with/slash')).toBe(true);
+            expect(isGroupId('multiple+signs+notphone')).toBe(true);
+            expect(isGroupId('+1234567890')).toBe(false);
+        });
+    });
+    describe('Deprecated Methods', () => {
+        it('should warn about deprecated receiveMessages', async () => {
+            const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+            await signalCli.receiveMessages();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('deprecated'));
+            consoleSpy.mockRestore();
+        });
+        it('should warn about deprecated startDaemon', async () => {
+            const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+            mockProcess.stdout.once.mockImplementation((event, callback) => {
+                if (event === 'data')
+                    callback();
+            });
+            await signalCli.startDaemon();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('deprecated'));
+            consoleSpy.mockRestore();
+        });
+        it('should warn about deprecated stopDaemon', () => {
+            const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+            signalCli.stopDaemon();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('deprecated'));
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('Complex Scenarios', () => {
+        beforeEach(() => {
+            jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
+        });
+        it('should handle group message with options', async () => {
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue({ results: [{ type: 'SUCCESS' }], timestamp: 123456 });
+            await signalCli.sendMessage('groupId==', 'Group message', {
+                mentions: [{ start: 0, length: 4, number: '+1111111111' }]
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalled();
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
+                message: 'Group message',
+                groupId: 'groupId=='
+            }));
+        });
+    });
+    describe('Error Handling', () => {
+        it('should reject when not connected', async () => {
+            const disconnectedSignal = new SignalCli_1.SignalCli('signal-cli', '+1234567890');
+            await expect(disconnectedSignal.sendMessage('+0987654321', 'test')).rejects.toThrow('Not connected');
+        });
+        it('should handle JSON-RPC errors correctly', () => {
+            const handleRpcResponse = signalCli.handleRpcResponse.bind(signalCli);
+            const mockPromise = {
+                resolve: jest.fn(),
+                reject: jest.fn(),
+            };
+            signalCli.requestPromises.set('error-id', mockPromise);
+            const errorResponse = '{"jsonrpc":"2.0","id":"error-id","error":{"code":-32600,"message":"Invalid Request"}}';
+            handleRpcResponse(errorResponse);
+            expect(mockPromise.reject).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('Invalid Request')
+            }));
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+/**
+ * Tests for SignalCli methods
+ * Covers additional methods not tested in SignalCli.test.ts
+ */
+export {};