signal-sdk 0.1.1 → 0.1.3

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+// Mock dependencies
+jest.mock('child_process');
+jest.mock('../config', () => ({
+    Logger: jest.fn().mockImplementation(() => ({
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    })),
+    validateConfig: jest.fn().mockReturnValue({
+        verbose: false,
+        logFile: undefined,
+        maxConcurrentRequests: 10,
+        minRequestInterval: 100,
+    }),
+}));
+describe('SignalCli - Simple Features', () => {
+    let signalCli;
+    const mockAccount = '+1234567890';
+    beforeEach(() => {
+        // Reset mocks and instance
+        jest.clearAllMocks();
+        signalCli = new SignalCli_1.SignalCli(mockAccount);
+        // Mock the internal request method to avoid real calls
+        signalCli.sendJsonRpcRequest = jest.fn();
+    });
+    describe('isRegistered', () => {
+        it('should return true when user is registered', async () => {
+            const mockResponse = [
+                {
+                    number: '+1987654321',
+                    isRegistered: true,
+                    uuid: 'uuid-123',
+                },
+            ];
+            signalCli.sendJsonRpcRequest.mockResolvedValue({
+                recipients: mockResponse,
+            });
+            const result = await signalCli.isRegistered('+1987654321');
+            expect(result).toBe(true);
+            expect(signalCli.sendJsonRpcRequest).toHaveBeenCalledWith('getUserStatus', expect.objectContaining({ recipients: ['+1987654321'] }));
+        });
+        it('should return false when user is not registered', async () => {
+            const mockResponse = [
+                {
+                    number: '+1987654321',
+                    isRegistered: false,
+                },
+            ];
+            signalCli.sendJsonRpcRequest.mockResolvedValue({
+                recipients: mockResponse,
+            });
+            const result = await signalCli.isRegistered('+1987654321');
+            expect(result).toBe(false);
+        });
+    });
+    describe('sendNoteToSelf', () => {
+        it('should send message to self account', async () => {
+            const message = 'Note to self test';
+            const mockResponse = {
+                timestamp: 123456789,
+                results: [],
+            };
+            // Mock sendMessage to verify it's called correctly
+            const sendMessageSpy = jest.spyOn(signalCli, 'sendMessage').mockResolvedValue(mockResponse);
+            await signalCli.sendNoteToSelf(message);
+            expect(sendMessageSpy).toHaveBeenCalledWith(mockAccount, message, expect.objectContaining({ noteToSelf: true }));
+        });
+        it('should throw error if account is not configured', async () => {
+            const noAccountCli = new SignalCli_1.SignalCli();
+            await expect(noAccountCli.sendNoteToSelf('fail')).rejects.toThrow('Account must be configured');
+        });
+    });
+});

package/dist/__tests__/SignalCli.test.js

@@ -54,7 +54,8 @@ describe('SignalCli', () => {
     });
     it('should send JSON-RPC request for sendMessage', async () => {
         // Mock sendJsonRpcRequest directly
-        const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+        const sendJsonRpcRequestSpy = jest
+            .spyOn(signalCli, 'sendJsonRpcRequest')
             .mockResolvedValue({ results: [{ type: 'SUCCESS' }], timestamp: 123456 });
         await signalCli.sendMessage('+10987654321', 'Hello, world!');
         expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', {
@@ -82,97 +83,96 @@ describe('SignalCli', () => {
             jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
         });
         it('should remove contact', async () => {
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
-                .mockResolvedValue({});
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
             await signalCli.removeContact('+1234567890', { forget: true });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('removeContact', {
                 account: '+1234567890',
                 recipient: '+1234567890',
-                forget: true
+                forget: true,
             });
         });
         it('should get user status', async () => {
             const mockResponse = {
-                recipients: [
-                    { number: '+1234567890', isRegistered: true, uuid: 'test-uuid' }
-                ]
+                recipients: [{ number: '+1234567890', isRegistered: true, uuid: 'test-uuid' }],
             };
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockResponse);
             const result = await signalCli.getUserStatus(['+1234567890']);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getUserStatus', {
                 account: '+1234567890',
-                recipients: ['+1234567890']
+                recipients: ['+1234567890'],
             });
             expect(result).toEqual([
-                { number: '+1234567890', isRegistered: true, uuid: 'test-uuid', username: undefined }
+                { number: '+1234567890', isRegistered: true, uuid: 'test-uuid', username: undefined },
             ]);
         });
         it('should send payment notification', async () => {
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue({ timestamp: 123456 });
             await signalCli.sendPaymentNotification('+1234567890', {
                 receipt: 'base64-receipt',
-                note: 'Payment for coffee'
+                note: 'Payment for coffee',
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPaymentNotification', {
                 account: '+1234567890',
                 recipient: '+1234567890',
                 receipt: 'base64-receipt',
-                note: 'Payment for coffee'
+                note: 'Payment for coffee',
             });
         });
         it('should upload sticker pack', async () => {
             const mockResponse = {
                 packId: 'pack-id',
                 packKey: 'pack-key',
-                installUrl: 'https://signal.org/stickers/pack-id'
+                installUrl: 'https://signal.org/stickers/pack-id',
             };
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockResponse);
             const result = await signalCli.uploadStickerPack({
-                path: '/path/to/manifest.json'
+                path: '/path/to/manifest.json',
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('uploadStickerPack', {
                 account: '+1234567890',
-                path: '/path/to/manifest.json'
+                path: '/path/to/manifest.json',
             });
             expect(result).toEqual(mockResponse);
         });
         it('should submit rate limit challenge', async () => {
             const mockResponse = {
                 success: true,
-                message: 'Challenge accepted'
+                message: 'Challenge accepted',
             };
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockResponse);
             const result = await signalCli.submitRateLimitChallenge('challenge-token', 'captcha-token');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('submitRateLimitChallenge', {
                 account: '+1234567890',
                 challenge: 'challenge-token',
-                captcha: 'captcha-token'
+                captcha: 'captcha-token',
             });
             expect(result).toEqual(mockResponse);
         });
         it('should start change number', async () => {
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
-                .mockResolvedValue({});
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
             await signalCli.startChangeNumber('+1987654321');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
                 account: '+1234567890',
                 number: '+1987654321',
-                voice: false
+                voice: false,
             });
         });
         it('should finish change number', async () => {
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
-                .mockResolvedValue({});
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
             await signalCli.finishChangeNumber('+1987654321', '123456', 'pin-code');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('finishChangeNumber', {
                 account: '+1234567890',
                 number: '+1987654321',
                 verificationCode: '123456',
-                pin: 'pin-code'
+                pin: 'pin-code',
             });
         });
     });
@@ -231,67 +231,71 @@ describe('SignalCli', () => {
         });
         it('should create a poll', async () => {
             const mockResponse = { timestamp: 123456789 };
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            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']
+                options: ['Red', 'Blue', 'Green'],
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollCreate', {
                 account: '+1234567890',
                 recipients: ['+1234567890'],
                 question: 'What is your favorite color?',
-                options: ['Red', 'Blue', 'Green']
+                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')
+            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']
+                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']
+                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')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockResponse);
             const result = await signalCli.sendPollVote('+1234567890', {
                 pollAuthor: '+9876543210',
                 pollTimestamp: 123456789,
-                optionIndexes: [0, 1]
+                optionIndexes: [0, 1],
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollVote', {
                 account: '+1234567890',
                 recipient: '+1234567890',
                 pollAuthor: '+9876543210',
                 pollTimestamp: 123456789,
-                options: [0, 1]
+                options: [0, 1],
             });
             expect(result).toEqual(mockResponse);
         });
         it('should terminate a poll', async () => {
             const mockResponse = { timestamp: 123456791 };
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockResponse);
             const result = await signalCli.sendPollTerminate('+1234567890', {
-                pollTimestamp: 123456789
+                pollTimestamp: 123456789,
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollTerminate', {
                 account: '+1234567890',
                 recipient: '+1234567890',
-                pollTimestamp: 123456789
+                pollTimestamp: 123456789,
             });
             expect(result).toEqual(mockResponse);
         });
@@ -303,68 +307,73 @@ describe('SignalCli', () => {
         });
         it('should get attachment by ID', async () => {
             const mockBase64 = 'base64-encoded-data';
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockBase64);
             const result = await signalCli.getAttachment({
-                id: 'attachment-123'
+                id: 'attachment-123',
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAttachment', {
                 account: '+1234567890',
-                id: 'attachment-123'
+                id: 'attachment-123',
             });
             expect(result).toBe(mockBase64);
         });
         it('should get contact avatar', async () => {
             const mockBase64 = 'base64-avatar-data';
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockBase64);
             const result = await signalCli.getAvatar({
-                contact: '+9876543210'
+                contact: '+9876543210',
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAvatar', {
                 account: '+1234567890',
-                contact: '+9876543210'
+                contact: '+9876543210',
             });
             expect(result).toBe(mockBase64);
         });
         it('should get profile avatar', async () => {
             const mockBase64 = 'base64-profile-avatar';
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockBase64);
             const result = await signalCli.getAvatar({
-                profile: '+1234567890'
+                profile: '+1234567890',
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAvatar', {
                 account: '+1234567890',
-                profile: '+1234567890'
+                profile: '+1234567890',
             });
             expect(result).toBe(mockBase64);
         });
         it('should get group avatar', async () => {
             const mockBase64 = 'base64-group-avatar';
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockBase64);
             const result = await signalCli.getAvatar({
-                groupId: 'group-123'
+                groupId: 'group-123',
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAvatar', {
                 account: '+1234567890',
-                groupId: 'group-123'
+                groupId: 'group-123',
             });
             expect(result).toBe(mockBase64);
         });
         it('should get sticker data', async () => {
             const mockBase64 = 'base64-sticker-data';
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockBase64);
             const result = await signalCli.getSticker({
                 packId: 'pack-123',
-                stickerId: 5
+                stickerId: 5,
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getSticker', {
                 account: '+1234567890',
                 packId: 'pack-123',
-                stickerId: 5
+                stickerId: 5,
             });
             expect(result).toBe(mockBase64);
         });
@@ -377,18 +386,19 @@ describe('SignalCli', () => {
         it('should update account settings', async () => {
             const mockResponse = {
                 username: 'myusername',
-                usernameLink: 'https://signal.me/#myusername'
+                usernameLink: 'https://signal.me/#myusername',
             };
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockResponse);
             const result = await signalCli.updateAccount({
                 deviceName: 'My Device',
-                username: 'myusername'
+                username: 'myusername',
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', {
                 account: '+1234567890',
                 deviceName: 'My Device',
-                username: 'myusername'
+                username: 'myusername',
             });
             expect(result.success).toBe(true);
             expect(result.username).toBe('myusername');
@@ -397,27 +407,74 @@ describe('SignalCli', () => {
             const mockResponse = {
                 accounts: [
                     { number: '+1234567890', name: 'Account 1', uuid: 'uuid-1' },
-                    { number: '+9876543210', name: 'Account 2', uuid: 'uuid-2' }
-                ]
+                    { number: '+9876543210', name: 'Account 2', uuid: 'uuid-2' },
+                ],
             };
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockResponse);
             const result = await signalCli.listAccountsDetailed();
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listAccounts');
             expect(result).toEqual(mockResponse.accounts);
         });
     });
+    // Test device management (v0.13.23+)
+    describe('Device Management', () => {
+        beforeEach(() => {
+            jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
+        });
+        it('should list devices', async () => {
+            const mockDevices = [
+                { id: 1, name: 'Device 1' },
+                { id: 2, name: 'Device 2' },
+            ];
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockDevices);
+            const result = await signalCli.listDevices();
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listDevices', {
+                account: '+1234567890',
+            });
+            expect(result).toEqual(mockDevices);
+        });
+        it('should update device name', async () => {
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(undefined);
+            await signalCli.updateDevice({
+                deviceId: 2,
+                deviceName: 'My Updated Device',
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateDevice', {
+                account: '+1234567890',
+                deviceId: 2,
+                deviceName: 'My Updated Device',
+            });
+        });
+        it('should validate device ID when updating', async () => {
+            await expect(signalCli.updateDevice({
+                deviceId: -1,
+                deviceName: 'Invalid',
+            })).rejects.toThrow();
+        });
+        it('should validate device name length', async () => {
+            const longName = 'a'.repeat(201);
+            await expect(signalCli.updateDevice({
+                deviceId: 2,
+                deviceName: longName,
+            })).rejects.toThrow();
+        });
+    });
     // 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({});
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
             await signalCli.sendContacts();
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendContacts', {
-                account: '+1234567890'
+                account: '+1234567890',
             });
         });
         it('should list groups with detailed information', async () => {
@@ -426,23 +483,24 @@ describe('SignalCli', () => {
                     id: 'group-1',
                     name: 'Test Group 1',
                     members: ['+1111111111', '+2222222222'],
-                    groupType: 'GROUP_V2'
+                    groupType: 'GROUP_V2',
                 },
                 {
                     id: 'group-2',
                     name: 'Test Group 2',
                     members: ['+3333333333'],
-                    groupType: 'GROUP_V2'
-                }
+                    groupType: 'GROUP_V2',
+                },
             ];
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockGroups);
             const result = await signalCli.listGroupsDetailed({
-                detailed: true
+                detailed: true,
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listGroups', {
                 account: '+1234567890',
-                detailed: true
+                detailed: true,
             });
             expect(result).toEqual(mockGroups);
         });
@@ -451,19 +509,20 @@ describe('SignalCli', () => {
                 {
                     id: 'group-1',
                     name: 'Specific Group',
-                    members: ['+1111111111']
-                }
+                    members: ['+1111111111'],
+                },
             ];
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue(mockGroups);
             const result = await signalCli.listGroupsDetailed({
                 groupIds: ['group-1'],
-                detailed: true
+                detailed: true,
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listGroups', {
                 account: '+1234567890',
                 detailed: true,
-                groupId: ['group-1']
+                groupId: ['group-1'],
             });
             expect(result).toEqual(mockGroups);
         });