signal-sdk 0.0.9 → 0.1.1

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

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Tests for enhanced parsing functionality (Phase 5)
+ * Tests profile and group data parsing methods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+describe('SignalCli - Enhanced Parsing (Phase 5)', () => {
+    let signal;
+    beforeEach(() => {
+        signal = new SignalCli_1.SignalCli('+33123456789');
+        // Mock sendJsonRpcRequest to avoid actual signal-cli calls
+        signal.sendJsonRpcRequest = jest.fn();
+    });
+    describe('parseContactProfile', () => {
+        it('should parse contact with full profile data', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John Doe',
+                uuid: 'test-uuid',
+                blocked: false,
+                givenName: 'John',
+                familyName: 'Doe',
+                mobileCoinAddress: 'mc1_test_address_123',
+                profileName: 'John Doe',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.givenName).toBe('John');
+            expect(parsed.familyName).toBe('Doe');
+            expect(parsed.mobileCoinAddress).toBe('mc1_test_address_123');
+            expect(parsed.profileName).toBe('John Doe');
+        });
+        it('should build profileName from givenName and familyName if missing', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John Doe',
+                uuid: 'test-uuid',
+                blocked: false,
+                givenName: 'John',
+                familyName: 'Doe',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.profileName).toBe('John Doe');
+        });
+        it('should use givenName as profileName if no familyName', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John',
+                uuid: 'test-uuid',
+                blocked: false,
+                givenName: 'John',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.profileName).toBe('John');
+        });
+        it('should handle contact with minimal data', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'Unknown',
+                blocked: false,
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.givenName).toBeUndefined();
+            expect(parsed.familyName).toBeUndefined();
+            expect(parsed.mobileCoinAddress).toBeUndefined();
+        });
+        it('should preserve additional contact fields', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John Doe',
+                uuid: 'test-uuid',
+                blocked: true,
+                profileAvatar: 'avatar.jpg',
+                color: 'blue',
+                archived: true,
+                mutedUntil: 123456789,
+                hideStory: true,
+                givenName: 'John',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.blocked).toBe(true);
+            expect(parsed.profileAvatar).toBe('avatar.jpg');
+            expect(parsed.color).toBe('blue');
+            expect(parsed.archived).toBe(true);
+            expect(parsed.mutedUntil).toBe(123456789);
+            expect(parsed.hideStory).toBe(true);
+        });
+    });
+    describe('parseGroupDetails', () => {
+        it('should parse group with full membership data', () => {
+            const group = {
+                groupId: 'group123==',
+                name: 'Test Group',
+                description: 'A test group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [
+                    { number: '+33111111111' },
+                    { number: '+33222222222' },
+                ],
+                pendingMembers: [
+                    { number: '+33333333333' },
+                ],
+                requestingMembers: [],
+                admins: [
+                    { number: '+33111111111' },
+                ],
+                banned: [
+                    { number: '+33444444444' },
+                ],
+                permissionAddMember: 'ONLY_ADMINS',
+                permissionEditDetails: 'ONLY_ADMINS',
+                permissionSendMessage: 'EVERY_MEMBER',
+                groupInviteLink: 'https://signal.group/test',
+            };
+            const parsed = signal.parseGroupDetails(group);
+            expect(parsed.pendingMembers).toHaveLength(1);
+            expect(parsed.pendingMembers[0].number).toBe('+33333333333');
+            expect(parsed.banned).toHaveLength(1);
+            expect(parsed.banned[0].number).toBe('+33444444444');
+            expect(parsed.inviteLink).toBe('https://signal.group/test');
+            expect(parsed.groupInviteLink).toBe('https://signal.group/test');
+        });
+        it('should normalize inviteLink field', () => {
+            const group1 = {
+                groupId: 'group123==',
+                name: 'Test Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [],
+                banned: [],
+                permissionAddMember: 'EVERY_MEMBER',
+                permissionEditDetails: 'EVERY_MEMBER',
+                permissionSendMessage: 'EVERY_MEMBER',
+                groupInviteLink: 'https://signal.group/test1',
+            };
+            const parsed1 = signal.parseGroupDetails(group1);
+            expect(parsed1.inviteLink).toBe('https://signal.group/test1');
+            expect(parsed1.groupInviteLink).toBe('https://signal.group/test1');
+            const group2 = {
+                ...group1,
+                groupInviteLink: undefined,
+                inviteLink: 'https://signal.group/test2',
+            };
+            const parsed2 = signal.parseGroupDetails(group2);
+            expect(parsed2.inviteLink).toBe('https://signal.group/test2');
+            expect(parsed2.groupInviteLink).toBe('https://signal.group/test2');
+        });
+        it('should ensure membership arrays exist', () => {
+            const group = {
+                groupId: 'group123==',
+                name: 'Minimal Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [],
+                banned: [],
+                permissionAddMember: 'EVERY_MEMBER',
+                permissionEditDetails: 'EVERY_MEMBER',
+                permissionSendMessage: 'EVERY_MEMBER',
+            };
+            const parsed = signal.parseGroupDetails(group);
+            expect(Array.isArray(parsed.members)).toBe(true);
+            expect(Array.isArray(parsed.pendingMembers)).toBe(true);
+            expect(Array.isArray(parsed.requestingMembers)).toBe(true);
+            expect(Array.isArray(parsed.admins)).toBe(true);
+            expect(Array.isArray(parsed.banned)).toBe(true);
+        });
+        it('should preserve group permissions', () => {
+            const group = {
+                groupId: 'group123==',
+                name: 'Restricted Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 3600,
+                members: [],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [],
+                banned: [],
+                permissionAddMember: 'ONLY_ADMINS',
+                permissionEditDetails: 'ONLY_ADMINS',
+                permissionSendMessage: 'ONLY_ADMINS',
+            };
+            const parsed = signal.parseGroupDetails(group);
+            expect(parsed.permissionAddMember).toBe('ONLY_ADMINS');
+            expect(parsed.permissionEditDetails).toBe('ONLY_ADMINS');
+            expect(parsed.permissionSendMessage).toBe('ONLY_ADMINS');
+            expect(parsed.messageExpirationTime).toBe(3600);
+        });
+    });
+    describe('getContactsWithProfiles', () => {
+        it('should return enriched contacts list', async () => {
+            const mockContacts = [
+                {
+                    number: '+33111111111',
+                    name: 'Alice',
+                    blocked: false,
+                    givenName: 'Alice',
+                    familyName: 'Smith',
+                },
+                {
+                    number: '+33222222222',
+                    name: 'Bob',
+                    blocked: false,
+                    givenName: 'Bob',
+                    mobileCoinAddress: 'mc1_bob',
+                },
+            ];
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue(mockContacts);
+            const enriched = await signal.getContactsWithProfiles();
+            expect(enriched).toHaveLength(2);
+            expect(enriched[0].profileName).toBe('Alice Smith');
+            expect(enriched[1].profileName).toBe('Bob');
+            expect(enriched[1].mobileCoinAddress).toBe('mc1_bob');
+        });
+    });
+    describe('getGroupsWithDetails', () => {
+        it('should return enriched groups list', async () => {
+            const mockGroups = [
+                {
+                    groupId: 'group1==',
+                    name: 'Group 1',
+                    isMember: true,
+                    isBlocked: false,
+                    messageExpirationTime: 0,
+                    members: [{ number: '+33111111111' }],
+                    pendingMembers: [{ number: '+33222222222' }],
+                    requestingMembers: [],
+                    admins: [{ number: '+33111111111' }],
+                    banned: [],
+                    permissionAddMember: 'EVERY_MEMBER',
+                    permissionEditDetails: 'EVERY_MEMBER',
+                    permissionSendMessage: 'EVERY_MEMBER',
+                    groupInviteLink: 'https://signal.group/group1',
+                },
+            ];
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue(mockGroups);
+            const enriched = await signal.getGroupsWithDetails();
+            expect(enriched).toHaveLength(1);
+            expect(enriched[0].inviteLink).toBe('https://signal.group/group1');
+            expect(enriched[0].pendingMembers).toHaveLength(1);
+        });
+        it('should support list options', async () => {
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue([]);
+            await signal.getGroupsWithDetails({ detailed: true });
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledWith('listGroups', expect.objectContaining({ detailed: true }));
+        });
+    });
+});

package/dist/__tests__/SignalCli.test.js

@@ -155,31 +155,23 @@ describe('SignalCli', () => {
             expect(result).toEqual(mockResponse);
         });
         it('should start change number', async () => {
-            const mockResponse = {
-                session: 'change-session-id',
-                challenge: 'challenge-token'
-            };
             const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
-                .mockResolvedValue(mockResponse);
-            const result = await signalCli.startChangeNumber('+1987654321');
+                .mockResolvedValue({});
+            await signalCli.startChangeNumber('+1987654321');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
                 account: '+1234567890',
                 number: '+1987654321',
                 voice: false
             });
-            expect(result).toEqual({
-                session: 'change-session-id',
-                newNumber: '+1987654321',
-                challenge: 'challenge-token'
-            });
         });
         it('should finish change number', async () => {
             const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue({});
-            await signalCli.finishChangeNumber('123456', 'pin-code');
+            await signalCli.finishChangeNumber('+1987654321', '123456', 'pin-code');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('finishChangeNumber', {
                 account: '+1234567890',
-                code: '123456',
+                number: '+1987654321',
+                verificationCode: '123456',
                 pin: 'pin-code'
             });
         });
@@ -232,4 +224,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 {};