signal-sdk 0.0.9 → 0.1.1

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

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * Advanced Features Tests for SignalCli
+ * Tests for new features added for 100% signal-cli coverage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+describe('SignalCli Advanced Features', () => {
+    let signalCli;
+    let sendJsonRpcRequestSpy;
+    beforeEach(() => {
+        signalCli = new SignalCli_1.SignalCli('+1234567890');
+        sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            .mockResolvedValue({ timestamp: Date.now(), results: [] });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('Advanced sendMessage Options', () => {
+        it('should send message with text styles', async () => {
+            await signalCli.sendMessage('+33123456789', 'Hello *bold* text', {
+                textStyles: [
+                    { start: 6, length: 6, style: 'BOLD' }
+                ]
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
+                message: 'Hello *bold* text',
+                textStyles: [
+                    { start: 6, length: 6, style: 'BOLD' }
+                ]
+            }));
+        });
+        it('should send message with mentions', async () => {
+            await signalCli.sendMessage('+33123456789', 'Hello @John', {
+                mentions: [
+                    { start: 6, length: 5, number: '+33111111111' }
+                ]
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
+                message: 'Hello @John',
+                mentions: [
+                    { start: 6, length: 5, number: '+33111111111' }
+                ]
+            }));
+        });
+        it('should send message with preview URL', async () => {
+            await signalCli.sendMessage('+33123456789', 'Check this out', {
+                previewUrl: 'https://example.com'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
+                message: 'Check this out',
+                previewUrl: 'https://example.com'
+            }));
+        });
+        it('should send message with quote and advanced fields', async () => {
+            await signalCli.sendMessage('+33123456789', 'I agree!', {
+                quote: {
+                    timestamp: 123456789,
+                    author: '+33111111111',
+                    text: 'Original message',
+                    mentions: [{ start: 0, length: 5, number: '+33222222222' }],
+                    textStyles: [{ start: 0, length: 8, style: 'BOLD' }]
+                }
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
+                message: 'I agree!',
+                quoteTimestamp: 123456789,
+                quoteAuthor: '+33111111111',
+                quoteMessage: 'Original message',
+                quoteMentions: [{ start: 0, length: 5, number: '+33222222222' }],
+                quoteTextStyles: [{ start: 0, length: 8, style: 'BOLD' }]
+            }));
+        });
+        it('should send message edit', async () => {
+            await signalCli.sendMessage('+33123456789', 'Corrected text', {
+                editTimestamp: 123456789
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
+                message: 'Corrected text',
+                editTimestamp: 123456789
+            }));
+        });
+        it('should send reply to story', async () => {
+            await signalCli.sendMessage('+33123456789', 'Nice story!', {
+                storyTimestamp: 123456789,
+                storyAuthor: '+33111111111'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
+                message: 'Nice story!',
+                storyTimestamp: 123456789,
+                storyAuthor: '+33111111111'
+            }));
+        });
+        it('should send message with noteToSelf flag', async () => {
+            await signalCli.sendMessage('+1234567890', 'Note to myself', {
+                noteToSelf: true
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
+                message: 'Note to myself',
+                noteToSelf: true
+            }));
+        });
+        it('should send message with endSession flag', async () => {
+            await signalCli.sendMessage('+33123456789', 'Goodbye', {
+                endSession: true
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
+                message: 'Goodbye',
+                endSession: true
+            }));
+        });
+    });
+    describe('receive() Method', () => {
+        it('should receive messages with default options', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue([
+                {
+                    timestamp: 123456789,
+                    source: '+33123456789',
+                    dataMessage: { message: 'Hello!' }
+                }
+            ]);
+            const messages = await signalCli.receive();
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
+                account: '+1234567890'
+            }));
+            expect(messages).toHaveLength(1);
+            expect(messages[0].text).toBe('Hello!');
+        });
+        it('should receive messages with custom timeout', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue([]);
+            await signalCli.receive({ timeout: 10 });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
+                timeout: 10
+            }));
+        });
+        it('should receive messages with maxMessages limit', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue([]);
+            await signalCli.receive({ maxMessages: 5 });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
+                maxMessages: 5
+            }));
+        });
+        it('should receive messages with ignoreAttachments', async () => {
+            await signalCli.receive({ ignoreAttachments: true });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
+                ignoreAttachments: true
+            }));
+        });
+        it('should receive messages with ignoreStories', async () => {
+            await signalCli.receive({ ignoreStories: true });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
+                ignoreStories: true
+            }));
+        });
+        it('should receive messages with sendReadReceipts', async () => {
+            await signalCli.receive({ sendReadReceipts: true });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
+                sendReadReceipts: true
+            }));
+        });
+        it('should handle empty message array', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue([]);
+            const messages = await signalCli.receive();
+            expect(messages).toEqual([]);
+        });
+    });
+    describe('Username Management Helpers', () => {
+        it('should set username', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue({
+                username: 'myuser.123',
+                usernameLink: 'https://signal.me/#myuser.123'
+            });
+            const result = await signalCli.setUsername('myuser');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
+                username: 'myuser'
+            }));
+            expect(result.success).toBe(true);
+            expect(result.username).toBe('myuser.123');
+        });
+        it('should delete username', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue({});
+            const result = await signalCli.deleteUsername();
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
+                deleteUsername: true
+            }));
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('Advanced Identity Management', () => {
+        it('should get safety number', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue([
+                {
+                    number: '+33123456789',
+                    safetyNumber: '12345 67890 12345 67890 12345 67890',
+                    trustLevel: 'TRUSTED'
+                }
+            ]);
+            const safetyNumber = await signalCli.getSafetyNumber('+33123456789');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listIdentities', expect.objectContaining({
+                number: '+33123456789'
+            }));
+            expect(safetyNumber).toBe('12345 67890 12345 67890 12345 67890');
+        });
+        it('should return null when safety number not found', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue([]);
+            const safetyNumber = await signalCli.getSafetyNumber('+33123456789');
+            expect(safetyNumber).toBeNull();
+        });
+        it('should verify safety number successfully', async () => {
+            // Mock listIdentities response
+            sendJsonRpcRequestSpy.mockResolvedValueOnce([
+                {
+                    number: '+33123456789',
+                    safetyNumber: '12345 67890 12345 67890 12345 67890',
+                    trustLevel: 'TRUSTED'
+                }
+            ]);
+            // Mock trustIdentity response
+            sendJsonRpcRequestSpy.mockResolvedValueOnce({});
+            const verified = await signalCli.verifySafetyNumber('+33123456789', '12345 67890 12345 67890 12345 67890');
+            expect(verified).toBe(true);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('trust', expect.objectContaining({
+                recipient: '+33123456789'
+            }));
+        });
+        it('should fail to verify incorrect safety number', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue([
+                {
+                    number: '+33123456789',
+                    safetyNumber: '12345 67890 12345 67890 12345 67890',
+                    trustLevel: 'TRUSTED'
+                }
+            ]);
+            const verified = await signalCli.verifySafetyNumber('+33123456789', '99999 99999 99999 99999 99999 99999');
+            expect(verified).toBe(false);
+        });
+        it('should list untrusted identities', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue([
+                { number: '+33111111111', trustLevel: 'TRUSTED' },
+                { number: '+33222222222', trustLevel: 'UNTRUSTED' },
+                { number: '+33333333333', trustLevel: 'TRUST_ON_FIRST_USE' },
+                { number: '+33444444444' }
+            ]);
+            const untrusted = await signalCli.listUntrustedIdentities();
+            expect(untrusted).toHaveLength(3);
+            expect(untrusted.map(i => i.number)).toEqual([
+                '+33222222222',
+                '+33333333333',
+                '+33444444444'
+            ]);
+        });
+    });
+    describe('Advanced Group Management', () => {
+        it('should send group invite link', async () => {
+            // Mock listGroups response
+            sendJsonRpcRequestSpy.mockResolvedValueOnce([
+                {
+                    groupId: 'group123==',
+                    name: 'Test Group',
+                    groupInviteLink: 'https://signal.group/...'
+                }
+            ]);
+            // Mock sendMessage response
+            sendJsonRpcRequestSpy.mockResolvedValueOnce({ timestamp: Date.now() });
+            await signalCli.sendGroupInviteLink('group123==', '+33123456789');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
+                message: expect.stringContaining('https://signal.group/'),
+                recipients: ['+33123456789']
+            }));
+        });
+        it('should throw error when group has no invite link', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue([
+                {
+                    groupId: 'group123==',
+                    name: 'Test Group'
+                }
+            ]);
+            await expect(signalCli.sendGroupInviteLink('group123==', '+33123456789')).rejects.toThrow('Group not found or does not have an invite link');
+        });
+        it('should set banned members', async () => {
+            await signalCli.setBannedMembers('group123==', ['+33111111111', '+33222222222']);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateGroup', expect.objectContaining({
+                groupId: 'group123==',
+                banMembers: ['+33111111111', '+33222222222']
+            }));
+        });
+        it('should reset group link', async () => {
+            await signalCli.resetGroupLink('group123==');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateGroup', expect.objectContaining({
+                groupId: 'group123==',
+                resetLink: true
+            }));
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+/**
+ * End-to-end integration tests for complete workflows (Phase 6)
+ * Tests realistic scenarios combining multiple operations
+ */
+export {};

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

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * End-to-end integration tests for complete workflows (Phase 6)
+ * Tests realistic scenarios combining multiple operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
+    let signal;
+    const mockSendResponse = {
+        timestamp: Date.now(),
+        results: [{ type: 'SUCCESS' }],
+    };
+    beforeEach(() => {
+        signal = new SignalCli_1.SignalCli('+33123456789');
+    });
+    describe('Complete Messaging Workflow', () => {
+        it('should send message with full options and handle response', async () => {
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValue(mockSendResponse);
+            const result = await signal.sendMessage('+33987654321', 'Hello!', {
+                attachments: ['/path/to/image.jpg'],
+                textStyles: [
+                    { start: 0, length: 5, style: 'BOLD' },
+                ],
+                mentions: [
+                    { start: 0, length: 5, number: '+33987654321' },
+                ],
+            });
+            expect(result.timestamp).toBeDefined();
+            expect(result.results).toBeDefined();
+        });
+        it('should send quoted message with attachments', async () => {
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValue(mockSendResponse);
+            const result = await signal.sendMessage('+33987654321', 'Reply', {
+                quote: {
+                    timestamp: 1234567890,
+                    author: '+33111111111',
+                    text: 'Original message',
+                },
+                attachments: ['/path/to/doc.pdf'],
+            });
+            expect(result.timestamp).toBeDefined();
+        });
+    });
+    describe('Contact Management Workflow', () => {
+        it('should manage contacts through complete lifecycle', async () => {
+            const mockContacts = [
+                {
+                    number: '+33111111111',
+                    name: 'Alice',
+                    blocked: false,
+                    givenName: 'Alice',
+                    familyName: 'Smith',
+                },
+                {
+                    number: '+33222222222',
+                    name: 'Bob',
+                    blocked: false,
+                },
+            ];
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce(mockContacts)
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce([mockContacts[0]]);
+            const contacts = await signal.getContactsWithProfiles();
+            expect(contacts).toHaveLength(2);
+            expect(contacts[0].profileName).toBe('Alice Smith');
+            await signal.updateContact('+33222222222', 'Bob Johnson');
+            const updated = await signal.listContacts();
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('Group Management Workflow', () => {
+        it('should manage group through complete lifecycle', async () => {
+            const mockGroup = {
+                groupId: 'group123==',
+                name: 'Test Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [
+                    { number: '+33111111111' },
+                    { number: '+33222222222' },
+                ],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [{ number: '+33111111111' }],
+                banned: [],
+                permissionAddMember: 'EVERY_MEMBER',
+                permissionEditDetails: 'EVERY_MEMBER',
+                permissionSendMessage: 'EVERY_MEMBER',
+                groupInviteLink: 'https://signal.group/test',
+            };
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce([mockGroup])
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce(mockSendResponse)
+                .mockResolvedValueOnce([
+                {
+                    ...mockGroup,
+                    members: [
+                        ...mockGroup.members,
+                        { number: '+33333333333' },
+                    ],
+                },
+            ]);
+            const groups = await signal.getGroupsWithDetails();
+            expect(groups).toHaveLength(1);
+            expect(groups[0].members).toHaveLength(2);
+            await signal.updateGroup('group123==', {
+                addMembers: ['+33333333333'],
+            });
+            await signal.sendMessage('group123==', 'Welcome new member!');
+            const updatedGroups = await signal.listGroups();
+            expect(updatedGroups[0].members).toHaveLength(3);
+        });
+    });
+    describe('Identity Management Workflow', () => {
+        it('should verify safety number before sending', async () => {
+            const mockSafetyNumber = '12345 67890 12345 67890 12345 67890';
+            const mockIdentities = [{
+                    safetyNumber: mockSafetyNumber,
+                    number: '+33987654321',
+                }];
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce(mockIdentities) // listIdentities
+                .mockResolvedValueOnce(mockIdentities) // listIdentities again for verify
+                .mockResolvedValueOnce(undefined) // trust
+                .mockResolvedValueOnce(mockSendResponse); // send
+            const safetyNumberResult = await signal.getSafetyNumber('+33987654321');
+            expect(safetyNumberResult).toBe(mockSafetyNumber);
+            await signal.verifySafetyNumber('+33987654321', mockSafetyNumber);
+            await signal.sendMessage('+33987654321', 'Secure message');
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledTimes(4);
+        });
+    });
+    describe('Username Management Workflow', () => {
+        it('should manage username lifecycle', async () => {
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce({ username: 'alice.01' })
+                .mockResolvedValueOnce(mockSendResponse)
+                .mockResolvedValueOnce(undefined);
+            const result = await signal.setUsername('alice.01');
+            expect(result.username).toBe('alice.01');
+            await signal.sendMessage('+33987654321', 'You can find me at @alice.01');
+            await signal.deleteUsername();
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('Receive and Process Messages Workflow', () => {
+        it('should receive and process incoming messages', async () => {
+            const mockMessages = [
+                {
+                    envelope: {
+                        source: '+33987654321',
+                        timestamp: Date.now(),
+                        dataMessage: {
+                            message: 'Hello!',
+                            timestamp: Date.now(),
+                        },
+                    },
+                },
+                {
+                    envelope: {
+                        source: '+33111111111',
+                        timestamp: Date.now(),
+                        dataMessage: {
+                            message: 'Hi there!',
+                            timestamp: Date.now(),
+                            groupInfo: {
+                                groupId: 'group123==',
+                            },
+                        },
+                    },
+                },
+            ];
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce(mockMessages)
+                .mockResolvedValueOnce(mockSendResponse)
+                .mockResolvedValueOnce(mockSendResponse);
+            const messages = await signal.receive();
+            expect(messages).toHaveLength(2);
+            // Only send messages if the source/groupId fields exist
+            const msg0 = messages[0];
+            const msg1 = messages[1];
+            if (msg0.envelope && msg0.envelope.source) {
+                await signal.sendMessage(msg0.envelope.source, 'Hello back!');
+            }
+            if (msg1.envelope && msg1.envelope.dataMessage &&
+                msg1.envelope.dataMessage.groupInfo &&
+                msg1.envelope.dataMessage.groupInfo.groupId) {
+                await signal.sendMessage(msg1.envelope.dataMessage.groupInfo.groupId, 'Hi everyone!');
+            }
+            // Verify at least receive was called (message sending depends on data structure)
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalled();
+        });
+    });
+    describe('Multi-Step Group Operations', () => {
+        it('should create group, add members, and send announcement', async () => {
+            const mockGroupId = 'newgroup123==';
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce({ groupId: mockGroupId })
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce(mockSendResponse);
+            const createResult = await signal.updateGroup(mockGroupId, {
+                name: 'New Team',
+            });
+            await signal.updateGroup(mockGroupId, {
+                addMembers: ['+33222222222', '+33333333333'],
+            });
+            await signal.updateGroup(mockGroupId, {
+                description: 'Our awesome team workspace',
+            });
+            await signal.sendMessage(mockGroupId, 'Welcome to the team! 🎉');
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledTimes(4);
+        });
+    });
+    describe('Error Handling in Workflows', () => {
+        it('should handle errors gracefully in message sending workflow', async () => {
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockRejectedValueOnce(new Error('Network error'))
+                .mockResolvedValueOnce(mockSendResponse);
+            await expect(signal.sendMessage('+33987654321', 'Test')).rejects.toThrow('Network error');
+            const result = await signal.sendMessage('+33987654321', 'Test');
+            expect(result.timestamp).toBeDefined();
+        });
+        it('should handle non-existent group in workflow', async () => {
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValue([]);
+            const groups = await signal.getGroupsWithDetails();
+            expect(groups).toHaveLength(0);
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockRejectedValue(new Error('Group not found'));
+            await expect(signal.sendMessage('nonexistent==', 'Test')).rejects.toThrow('Group not found');
+        });
+    });
+});

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

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