signal-sdk 0.1.0 → 0.1.2

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.js

@@ -34,7 +34,12 @@ describe('SignalCli Integration Tests', () => {
     afterEach(() => {
         if (signalCli) {
             signalCli.disconnect();
+            // Clean up all listeners
+            signalCli.removeAllListeners();
         }
+        // Clear all timers and mocks
+        jest.clearAllTimers();
+        jest.clearAllMocks();
     });
     describe('Connection Lifecycle', () => {
         it('should handle multiple connect/disconnect cycles', async () => {
@@ -62,11 +67,13 @@ describe('SignalCli Integration Tests', () => {
                 }
             });
             const shutdownPromise = signalCli.gracefulShutdown();
-            // Simulate timeout and force kill
-            setTimeout(() => {
+            // Simulate timeout and force kill with unref to prevent hanging
+            const timer = setTimeout(() => {
                 if (closeCallback)
                     closeCallback(0);
             }, 100);
+            if (timer.unref)
+                timer.unref();
             await expect(shutdownPromise).resolves.toBeUndefined();
         }, 10000); // Increase timeout to 10 seconds
         it('should handle stderr data with different log levels', async () => {

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

@@ -71,7 +71,7 @@ describe('SignalCli Methods Tests', () => {
         it('should send view-once message', async () => {
             await signalCli.sendMessage('+1234567890', 'View once', { isViewOnce: true });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
-                isViewOnce: true
+                viewOnce: true
             }));
         });
         it('should send reaction', async () => {
@@ -401,6 +401,90 @@ describe('SignalCli Methods Tests', () => {
             }));
         });
     });
+    describe('Update Account Methods', () => {
+        it('should update account with device name', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue({ username: 'user.123' });
+            const result = await signalCli.updateAccount({ deviceName: 'New Device' });
+            expect(result.success).toBe(true);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
+                deviceName: 'New Device'
+            }));
+        });
+        it('should update account with username', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue({ username: 'newuser.456', usernameLink: 'link' });
+            const result = await signalCli.updateAccount({ username: 'newuser.456' });
+            expect(result.success).toBe(true);
+            expect(result.username).toBe('newuser.456');
+        });
+        it('should delete username', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue({});
+            await signalCli.updateAccount({ deleteUsername: true });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
+                deleteUsername: true
+            }));
+        });
+        it('should update privacy settings', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue({});
+            await signalCli.updateAccount({
+                unrestrictedUnidentifiedSender: true,
+                discoverableByNumber: false,
+                numberSharing: false
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
+                unrestrictedUnidentifiedSender: true,
+                discoverableByNumber: false,
+                numberSharing: false
+            }));
+        });
+        it('should handle update account error', async () => {
+            sendJsonRpcRequestSpy.mockRejectedValue(new Error('Update failed'));
+            const result = await signalCli.updateAccount({ deviceName: 'Device' });
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('Device Management Methods (v0.13.23+)', () => {
+        it('should list devices', async () => {
+            const mockDevices = [
+                { id: 1, name: 'Primary', lastSeen: Date.now() },
+                { id: 2, name: 'Tablet', lastSeen: Date.now() }
+            ];
+            sendJsonRpcRequestSpy.mockResolvedValue(mockDevices);
+            const result = await signalCli.listDevices();
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listDevices', {
+                account: '+1234567890'
+            });
+            expect(result).toEqual(mockDevices);
+        });
+        it('should update device name', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue(undefined);
+            await signalCli.updateDevice({
+                deviceId: 3,
+                deviceName: 'My Laptop'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateDevice', {
+                account: '+1234567890',
+                deviceId: 3,
+                deviceName: 'My Laptop'
+            });
+        });
+        it('should validate device ID', async () => {
+            await expect(signalCli.updateDevice({
+                deviceId: 0,
+                deviceName: 'Invalid'
+            })).rejects.toThrow();
+            await expect(signalCli.updateDevice({
+                deviceId: -5,
+                deviceName: 'Invalid'
+            })).rejects.toThrow();
+        });
+        it('should validate device name is not too long', async () => {
+            const longName = 'x'.repeat(300);
+            await expect(signalCli.updateDevice({
+                deviceId: 2,
+                deviceName: longName
+            })).rejects.toThrow();
+        });
+    });
     describe('Update Account Methods', () => {
         it('should update account with device name', async () => {
             sendJsonRpcRequestSpy.mockResolvedValue({ username: 'user.123' });
@@ -467,4 +551,90 @@ describe('SignalCli Methods Tests', () => {
             }));
         });
     });
+    describe('Phone Number Change Methods', () => {
+        it('should start change number with SMS', async () => {
+            await signalCli.startChangeNumber('+33612345678');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
+                account: '+1234567890',
+                number: '+33612345678',
+                voice: false
+            });
+        });
+        it('should start change number with voice verification', async () => {
+            await signalCli.startChangeNumber('+33612345678', true);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
+                account: '+1234567890',
+                number: '+33612345678',
+                voice: true
+            });
+        });
+        it('should start change number with captcha', async () => {
+            const captcha = 'captcha_token_12345';
+            await signalCli.startChangeNumber('+33612345678', false, captcha);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
+                account: '+1234567890',
+                number: '+33612345678',
+                voice: false,
+                captcha
+            });
+        });
+        it('should validate phone number in startChangeNumber', async () => {
+            await expect(signalCli.startChangeNumber('invalid')).rejects.toThrow();
+        });
+        it('should finish change number without PIN', async () => {
+            await signalCli.finishChangeNumber('+33612345678', '123456');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('finishChangeNumber', {
+                account: '+1234567890',
+                number: '+33612345678',
+                verificationCode: '123456'
+            });
+        });
+        it('should finish change number with PIN', async () => {
+            await signalCli.finishChangeNumber('+33612345678', '123456', '1234');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('finishChangeNumber', {
+                account: '+1234567890',
+                number: '+33612345678',
+                verificationCode: '123456',
+                pin: '1234'
+            });
+        });
+        it('should validate phone number in finishChangeNumber', async () => {
+            await expect(signalCli.finishChangeNumber('invalid', '123456')).rejects.toThrow();
+        });
+        it('should require verification code in finishChangeNumber', async () => {
+            await expect(signalCli.finishChangeNumber('+33612345678', '')).rejects.toThrow('Verification code is required');
+        });
+    });
+    describe('Payment Notification Methods', () => {
+        it('should send payment notification', async () => {
+            const receipt = 'base64EncodedReceipt';
+            const note = 'Thanks for dinner!';
+            const recipient = '+1111111111';
+            sendJsonRpcRequestSpy.mockResolvedValue({ timestamp: 1234567890 });
+            const result = await signalCli.sendPaymentNotification(recipient, { receipt, note });
+            expect(result.timestamp).toBe(1234567890);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPaymentNotification', {
+                account: '+1234567890',
+                recipient,
+                receipt,
+                note
+            });
+        });
+        it('should send payment notification without note', async () => {
+            const receipt = 'base64EncodedReceipt';
+            const recipient = '+1111111111';
+            await signalCli.sendPaymentNotification(recipient, { receipt });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPaymentNotification', {
+                account: '+1234567890',
+                recipient,
+                receipt
+            });
+        });
+        it('should validate recipient in sendPaymentNotification', async () => {
+            await expect(signalCli.sendPaymentNotification('invalid', { receipt: 'test' })).rejects.toThrow();
+        });
+        it('should require receipt in sendPaymentNotification', async () => {
+            await expect(signalCli.sendPaymentNotification('+1111111111', { receipt: '' })).rejects.toThrow('Payment receipt is required');
+        });
+    });
 });

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

@@ -0,0 +1,5 @@
+/**
+ * Tests for enhanced parsing functionality (Phase 5)
+ * Tests profile and group data parsing methods
+ */
+export {};