signal-sdk 0.0.9 → 0.1.0

package/dist/__tests__/SignalCli.test.js

@@ -232,4 +232,248 @@ describe('SignalCli', () => {
             Object.defineProperty(process, 'platform', { value: originalPlatform });
         });
     });
+    // Test v0.1.0 features: Polls
+    describe('Poll Management', () => {
+        beforeEach(() => {
+            jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
+        });
+        it('should create a poll', async () => {
+            const mockResponse = { timestamp: 123456789 };
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockResponse);
+            const result = await signalCli.sendPollCreate({
+                recipients: ['+1234567890'],
+                question: 'What is your favorite color?',
+                options: ['Red', 'Blue', 'Green']
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollCreate', {
+                account: '+1234567890',
+                recipients: ['+1234567890'],
+                question: 'What is your favorite color?',
+                options: ['Red', 'Blue', 'Green']
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it('should create a group poll', async () => {
+            const mockResponse = { timestamp: 123456789 };
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockResponse);
+            const result = await signalCli.sendPollCreate({
+                groupId: 'group-123',
+                question: 'Best meeting time?',
+                options: ['9 AM', '2 PM', '4 PM']
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollCreate', {
+                account: '+1234567890',
+                groupId: 'group-123',
+                question: 'Best meeting time?',
+                options: ['9 AM', '2 PM', '4 PM']
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it('should vote on a poll', async () => {
+            const mockResponse = { timestamp: 123456790 };
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockResponse);
+            const result = await signalCli.sendPollVote('+1234567890', {
+                pollAuthor: '+9876543210',
+                pollTimestamp: 123456789,
+                optionIndexes: [0, 1]
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollVote', {
+                account: '+1234567890',
+                recipient: '+1234567890',
+                pollAuthor: '+9876543210',
+                pollTimestamp: 123456789,
+                options: [0, 1]
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it('should terminate a poll', async () => {
+            const mockResponse = { timestamp: 123456791 };
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockResponse);
+            const result = await signalCli.sendPollTerminate('+1234567890', {
+                pollTimestamp: 123456789
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollTerminate', {
+                account: '+1234567890',
+                recipient: '+1234567890',
+                pollTimestamp: 123456789
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    // Test v0.1.0 features: Attachment Retrieval
+    describe('Attachment Retrieval', () => {
+        beforeEach(() => {
+            jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
+        });
+        it('should get attachment by ID', async () => {
+            const mockBase64 = 'base64-encoded-data';
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockBase64);
+            const result = await signalCli.getAttachment({
+                id: 'attachment-123'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAttachment', {
+                account: '+1234567890',
+                id: 'attachment-123'
+            });
+            expect(result).toBe(mockBase64);
+        });
+        it('should get contact avatar', async () => {
+            const mockBase64 = 'base64-avatar-data';
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockBase64);
+            const result = await signalCli.getAvatar({
+                contact: '+9876543210'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAvatar', {
+                account: '+1234567890',
+                contact: '+9876543210'
+            });
+            expect(result).toBe(mockBase64);
+        });
+        it('should get profile avatar', async () => {
+            const mockBase64 = 'base64-profile-avatar';
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockBase64);
+            const result = await signalCli.getAvatar({
+                profile: '+1234567890'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAvatar', {
+                account: '+1234567890',
+                profile: '+1234567890'
+            });
+            expect(result).toBe(mockBase64);
+        });
+        it('should get group avatar', async () => {
+            const mockBase64 = 'base64-group-avatar';
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockBase64);
+            const result = await signalCli.getAvatar({
+                groupId: 'group-123'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAvatar', {
+                account: '+1234567890',
+                groupId: 'group-123'
+            });
+            expect(result).toBe(mockBase64);
+        });
+        it('should get sticker data', async () => {
+            const mockBase64 = 'base64-sticker-data';
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockBase64);
+            const result = await signalCli.getSticker({
+                packId: 'pack-123',
+                stickerId: 5
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getSticker', {
+                account: '+1234567890',
+                packId: 'pack-123',
+                stickerId: 5
+            });
+            expect(result).toBe(mockBase64);
+        });
+    });
+    // Test v0.1.0 features: Account Management
+    describe('Account Management', () => {
+        beforeEach(() => {
+            jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
+        });
+        it('should update account settings', async () => {
+            const mockResponse = {
+                username: 'myusername',
+                usernameLink: 'https://signal.me/#myusername'
+            };
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockResponse);
+            const result = await signalCli.updateAccount({
+                deviceName: 'My Device',
+                username: 'myusername'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', {
+                account: '+1234567890',
+                deviceName: 'My Device',
+                username: 'myusername'
+            });
+            expect(result.success).toBe(true);
+            expect(result.username).toBe('myusername');
+        });
+        it('should list accounts with details', async () => {
+            const mockResponse = {
+                accounts: [
+                    { number: '+1234567890', name: 'Account 1', uuid: 'uuid-1' },
+                    { number: '+9876543210', name: 'Account 2', uuid: 'uuid-2' }
+                ]
+            };
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockResponse);
+            const result = await signalCli.listAccountsDetailed();
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listAccounts');
+            expect(result).toEqual(mockResponse.accounts);
+        });
+    });
+    // Test v0.1.0 features: Synchronization
+    describe('Synchronization', () => {
+        beforeEach(() => {
+            jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
+        });
+        it('should send contacts to linked devices', async () => {
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue({});
+            await signalCli.sendContacts();
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendContacts', {
+                account: '+1234567890'
+            });
+        });
+        it('should list groups with detailed information', async () => {
+            const mockGroups = [
+                {
+                    id: 'group-1',
+                    name: 'Test Group 1',
+                    members: ['+1111111111', '+2222222222'],
+                    groupType: 'GROUP_V2'
+                },
+                {
+                    id: 'group-2',
+                    name: 'Test Group 2',
+                    members: ['+3333333333'],
+                    groupType: 'GROUP_V2'
+                }
+            ];
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockGroups);
+            const result = await signalCli.listGroupsDetailed({
+                detailed: true
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listGroups', {
+                account: '+1234567890',
+                detailed: true
+            });
+            expect(result).toEqual(mockGroups);
+        });
+        it('should filter groups by ID', async () => {
+            const mockGroups = [
+                {
+                    id: 'group-1',
+                    name: 'Specific Group',
+                    members: ['+1111111111']
+                }
+            ];
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockGroups);
+            const result = await signalCli.listGroupsDetailed({
+                groupIds: ['group-1'],
+                detailed: true
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listGroups', {
+                account: '+1234567890',
+                detailed: true,
+                groupId: ['group-1']
+            });
+            expect(result).toEqual(mockGroups);
+        });
+    });
 });

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

@@ -0,0 +1,5 @@
+/**
+ * Additional tests for config.ts
+ * Tests configuration validation and logger functionality
+ */
+export {};

package/dist/__tests__/config.test.js

@@ -0,0 +1,252 @@
+"use strict";
+/**
+ * Additional tests for config.ts
+ * Tests configuration validation and logger functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../config");
+describe('Config Additional Tests', () => {
+    describe('validateConfig', () => {
+        test('should return default config when no user config provided', () => {
+            const config = (0, config_1.validateConfig)();
+            expect(config).toEqual(config_1.DEFAULT_CONFIG);
+        });
+        test('should merge user config with defaults', () => {
+            const userConfig = {
+                verbose: true,
+                maxRetries: 5
+            };
+            const config = (0, config_1.validateConfig)(userConfig);
+            expect(config.verbose).toBe(true);
+            expect(config.maxRetries).toBe(5);
+            expect(config.connectionTimeout).toBe(config_1.DEFAULT_CONFIG.connectionTimeout);
+        });
+        test('should throw error for negative connectionTimeout', () => {
+            expect(() => (0, config_1.validateConfig)({ connectionTimeout: -1 }))
+                .toThrow('connectionTimeout must be non-negative');
+        });
+        test('should throw error for negative requestTimeout', () => {
+            expect(() => (0, config_1.validateConfig)({ requestTimeout: -100 }))
+                .toThrow('requestTimeout must be non-negative');
+        });
+        test('should throw error for negative maxRetries', () => {
+            expect(() => (0, config_1.validateConfig)({ maxRetries: -5 }))
+                .toThrow('maxRetries must be non-negative');
+        });
+        test('should throw error for negative retryDelay', () => {
+            expect(() => (0, config_1.validateConfig)({ retryDelay: -1000 }))
+                .toThrow('retryDelay must be non-negative');
+        });
+        test('should throw error for maxConcurrentRequests less than 1', () => {
+            expect(() => (0, config_1.validateConfig)({ maxConcurrentRequests: 0 }))
+                .toThrow('maxConcurrentRequests must be at least 1');
+            expect(() => (0, config_1.validateConfig)({ maxConcurrentRequests: -1 }))
+                .toThrow('maxConcurrentRequests must be at least 1');
+        });
+        test('should throw error for negative minRequestInterval', () => {
+            expect(() => (0, config_1.validateConfig)({ minRequestInterval: -50 }))
+                .toThrow('minRequestInterval must be non-negative');
+        });
+        test('should accept all valid trustNewIdentities values', () => {
+            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'on-first-use' }))
+                .not.toThrow();
+            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'always' }))
+                .not.toThrow();
+            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'never' }))
+                .not.toThrow();
+        });
+        test('should accept zero values for valid fields', () => {
+            const config = (0, config_1.validateConfig)({
+                connectionTimeout: 0,
+                requestTimeout: 0,
+                maxRetries: 0,
+                retryDelay: 0,
+                minRequestInterval: 0
+            });
+            expect(config.connectionTimeout).toBe(0);
+            expect(config.requestTimeout).toBe(0);
+            expect(config.maxRetries).toBe(0);
+            expect(config.retryDelay).toBe(0);
+            expect(config.minRequestInterval).toBe(0);
+        });
+        test('should handle all configuration options', () => {
+            const fullConfig = {
+                signalCliPath: '/custom/path/signal-cli',
+                account: '+1234567890',
+                connectionTimeout: 60000,
+                requestTimeout: 120000,
+                enableRetry: false,
+                maxRetries: 10,
+                retryDelay: 2000,
+                verbose: true,
+                logFile: '/var/log/signal.log',
+                maxConcurrentRequests: 10,
+                minRequestInterval: 200,
+                autoReconnect: false,
+                trustNewIdentities: 'never',
+                disableSendLog: true
+            };
+            const config = (0, config_1.validateConfig)(fullConfig);
+            expect(config).toMatchObject(fullConfig);
+        });
+    });
+    describe('Logger', () => {
+        let logger;
+        beforeEach(() => {
+            logger = new config_1.Logger({
+                level: 'debug',
+                enableConsole: true,
+                enableFile: false,
+                includeTimestamp: true,
+                includeLevel: true
+            });
+        });
+        test('should create logger with default config', () => {
+            const defaultLogger = new config_1.Logger();
+            expect(defaultLogger).toBeDefined();
+        });
+        test('should log debug messages', () => {
+            const consoleSpy = jest.spyOn(console, 'debug').mockImplementation();
+            logger.debug('Test debug message');
+            expect(consoleSpy).toHaveBeenCalled();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Test debug message'));
+            consoleSpy.mockRestore();
+        });
+        test('should log info messages', () => {
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
+            logger.info('Test info message');
+            expect(consoleSpy).toHaveBeenCalled();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Test info message'));
+            consoleSpy.mockRestore();
+        });
+        test('should log warn messages', () => {
+            const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+            logger.warn('Test warning message');
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('WARN'));
+            consoleSpy.mockRestore();
+        });
+        test('should log error messages', () => {
+            const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+            logger.error('Test error message');
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('ERROR'));
+            consoleSpy.mockRestore();
+        });
+        test('should include timestamp when configured', () => {
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
+            logger.info('Timestamped message');
+            expect(consoleSpy).toHaveBeenCalled();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringMatching(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\]/));
+            consoleSpy.mockRestore();
+        });
+        test('should not log when console is disabled', () => {
+            const consoleLogger = new config_1.Logger({
+                level: 'info',
+                enableConsole: false,
+                enableFile: false,
+                includeTimestamp: true,
+                includeLevel: true
+            });
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            consoleLogger.info('Should not appear in console');
+            expect(consoleSpy).not.toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+        test('should respect log level', () => {
+            const infoLogger = new config_1.Logger({
+                level: 'info',
+                enableConsole: true,
+                enableFile: false,
+                includeTimestamp: false,
+                includeLevel: true
+            });
+            const consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation();
+            const consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation();
+            infoLogger.debug('Debug message'); // Should not log
+            infoLogger.info('Info message'); // Should log
+            expect(consoleDebugSpy).not.toHaveBeenCalled();
+            expect(consoleInfoSpy).toHaveBeenCalledTimes(1);
+            expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('Info message'));
+            consoleDebugSpy.mockRestore();
+            consoleInfoSpy.mockRestore();
+        });
+        test('should log with additional data', () => {
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
+            logger.info('Message with data', { key: 'value', number: 42 });
+            expect(consoleSpy).toHaveBeenCalled();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('key'));
+            consoleSpy.mockRestore();
+        });
+        test('should handle error log level hierarchy', () => {
+            const errorLogger = new config_1.Logger({
+                level: 'error',
+                enableConsole: true,
+                enableFile: false,
+                includeTimestamp: false,
+                includeLevel: true
+            });
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+            errorLogger.debug('Debug'); // Should not log
+            errorLogger.info('Info'); // Should not log
+            errorLogger.warn('Warn'); // Should not log
+            errorLogger.error('Error'); // Should log
+            expect(consoleLogSpy).not.toHaveBeenCalled();
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+            expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+            consoleLogSpy.mockRestore();
+            consoleWarnSpy.mockRestore();
+            consoleErrorSpy.mockRestore();
+        });
+        test('should format messages without timestamp', () => {
+            const noTimestampLogger = new config_1.Logger({
+                level: 'info',
+                enableConsole: true,
+                enableFile: false,
+                includeTimestamp: false,
+                includeLevel: true
+            });
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
+            noTimestampLogger.info('No timestamp');
+            expect(consoleSpy).toHaveBeenCalled();
+            const calls = consoleSpy.mock.calls[0][0];
+            expect(calls).not.toMatch(/\[\d{4}-\d{2}-\d{2}T/);
+            consoleSpy.mockRestore();
+        });
+        test('should format messages without level', () => {
+            const noLevelLogger = new config_1.Logger({
+                level: 'info',
+                enableConsole: true,
+                enableFile: false,
+                includeTimestamp: false,
+                includeLevel: false
+            });
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
+            noLevelLogger.info('No level');
+            expect(consoleSpy).toHaveBeenCalled();
+            const calls = consoleSpy.mock.calls[0][0];
+            expect(calls).not.toContain('[INFO]');
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('DEFAULT_CONFIG', () => {
+        test('should have sensible defaults', () => {
+            expect(config_1.DEFAULT_CONFIG.connectionTimeout).toBe(30000);
+            expect(config_1.DEFAULT_CONFIG.requestTimeout).toBe(60000);
+            expect(config_1.DEFAULT_CONFIG.enableRetry).toBe(true);
+            expect(config_1.DEFAULT_CONFIG.maxRetries).toBe(3);
+            expect(config_1.DEFAULT_CONFIG.retryDelay).toBe(1000);
+            expect(config_1.DEFAULT_CONFIG.verbose).toBe(false);
+            expect(config_1.DEFAULT_CONFIG.maxConcurrentRequests).toBe(5);
+            expect(config_1.DEFAULT_CONFIG.minRequestInterval).toBe(100);
+            expect(config_1.DEFAULT_CONFIG.autoReconnect).toBe(true);
+            expect(config_1.DEFAULT_CONFIG.trustNewIdentities).toBe('on-first-use');
+            expect(config_1.DEFAULT_CONFIG.disableSendLog).toBe(false);
+        });
+        test('should have empty strings for optional paths', () => {
+            expect(config_1.DEFAULT_CONFIG.signalCliPath).toBe('');
+            expect(config_1.DEFAULT_CONFIG.account).toBe('');
+            expect(config_1.DEFAULT_CONFIG.logFile).toBe('');
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+/**
+ * Additional tests for errors.ts
+ * Tests all error classes and their properties
+ */
+export {};