signal-sdk 0.1.0 → 0.1.2

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

@@ -0,0 +1,4 @@
+/**
+ * Tests for MultiAccountManager
+ */
+export {};

package/dist/__tests__/MultiAccountManager.test.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Tests for MultiAccountManager
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const MultiAccountManager_1 = require("../MultiAccountManager");
+const SignalCli_1 = require("../SignalCli");
+// Mock SignalCli
+jest.mock('../SignalCli');
+describe('MultiAccountManager', () => {
+    let manager;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        manager = new MultiAccountManager_1.MultiAccountManager({
+            dataPath: '/tmp/test-data',
+            verbose: false
+        });
+    });
+    afterEach(async () => {
+        if (manager) {
+            await manager.shutdown();
+        }
+    });
+    describe('Account Management', () => {
+        it('should add an account', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            expect(instance).toBeInstanceOf(SignalCli_1.SignalCli);
+            expect(manager.hasAccount('+33123456789')).toBe(true);
+            expect(manager.getAccounts()).toContain('+33123456789');
+        });
+        it('should emit accountAdded event', async () => {
+            const spy = jest.fn();
+            manager.on('accountAdded', spy);
+            await manager.addAccount('+33123456789');
+            expect(spy).toHaveBeenCalledWith('+33123456789');
+        });
+        it('should throw error when adding duplicate account', async () => {
+            await manager.addAccount('+33123456789');
+            await expect(manager.addAccount('+33123456789')).rejects.toThrow('Account +33123456789 already exists');
+        });
+        it('should remove an account', async () => {
+            await manager.addAccount('+33123456789');
+            await manager.removeAccount('+33123456789');
+            expect(manager.hasAccount('+33123456789')).toBe(false);
+            expect(manager.getAccounts()).not.toContain('+33123456789');
+        });
+        it('should emit accountRemoved event', async () => {
+            const spy = jest.fn();
+            await manager.addAccount('+33123456789');
+            manager.on('accountRemoved', spy);
+            await manager.removeAccount('+33123456789');
+            expect(spy).toHaveBeenCalledWith('+33123456789');
+        });
+        it('should throw error when removing non-existent account', async () => {
+            await expect(manager.removeAccount('+33123456789')).rejects.toThrow('Account +33123456789 not found');
+        });
+        it('should get specific account instance', async () => {
+            await manager.addAccount('+33123456789');
+            const instance = manager.getAccount('+33123456789');
+            expect(instance).toBeInstanceOf(SignalCli_1.SignalCli);
+        });
+        it('should return undefined for non-existent account', () => {
+            const instance = manager.getAccount('+33999999999');
+            expect(instance).toBeUndefined();
+        });
+        it('should get all account numbers', async () => {
+            await manager.addAccount('+33123456789');
+            await manager.addAccount('+33987654321');
+            const accounts = manager.getAccounts();
+            expect(accounts).toHaveLength(2);
+            expect(accounts).toContain('+33123456789');
+            expect(accounts).toContain('+33987654321');
+        });
+    });
+    describe('Connection Management', () => {
+        it('should connect a specific account', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.connect = jest.fn().mockResolvedValue(undefined);
+            await manager.connect('+33123456789');
+            expect(instance.connect).toHaveBeenCalled();
+        });
+        it('should emit accountConnected event', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.connect = jest.fn().mockResolvedValue(undefined);
+            const spy = jest.fn();
+            manager.on('accountConnected', spy);
+            await manager.connect('+33123456789');
+            expect(spy).toHaveBeenCalledWith('+33123456789');
+        });
+        it('should disconnect a specific account', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.connect = jest.fn().mockResolvedValue(undefined);
+            instance.disconnect = jest.fn().mockResolvedValue(undefined);
+            await manager.connect('+33123456789');
+            await manager.disconnect('+33123456789');
+            expect(instance.disconnect).toHaveBeenCalled();
+        });
+        it('should emit accountDisconnected event', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.connect = jest.fn().mockResolvedValue(undefined);
+            instance.disconnect = jest.fn().mockResolvedValue(undefined);
+            const spy = jest.fn();
+            await manager.connect('+33123456789');
+            manager.on('accountDisconnected', spy);
+            await manager.disconnect('+33123456789');
+            expect(spy).toHaveBeenCalledWith('+33123456789');
+        });
+        it('should connect all accounts', async () => {
+            const instance1 = await manager.addAccount('+33123456789');
+            const instance2 = await manager.addAccount('+33987654321');
+            instance1.connect = jest.fn().mockResolvedValue(undefined);
+            instance2.connect = jest.fn().mockResolvedValue(undefined);
+            await manager.connectAll();
+            expect(instance1.connect).toHaveBeenCalled();
+            expect(instance2.connect).toHaveBeenCalled();
+        });
+        it('should disconnect all accounts', async () => {
+            const instance1 = await manager.addAccount('+33123456789');
+            const instance2 = await manager.addAccount('+33987654321');
+            instance1.connect = jest.fn().mockResolvedValue(undefined);
+            instance2.connect = jest.fn().mockResolvedValue(undefined);
+            instance1.disconnect = jest.fn().mockResolvedValue(undefined);
+            instance2.disconnect = jest.fn().mockResolvedValue(undefined);
+            await manager.connectAll();
+            await manager.disconnectAll();
+            expect(instance1.disconnect).toHaveBeenCalled();
+            expect(instance2.disconnect).toHaveBeenCalled();
+        });
+        it('should handle connection errors gracefully', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.connect = jest.fn().mockRejectedValue(new Error('Connection failed'));
+            await expect(manager.connect('+33123456789')).rejects.toThrow('Connection failed');
+        });
+    });
+    describe('Message Sending', () => {
+        it('should send message from specific account', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.sendMessage = jest.fn().mockResolvedValue({
+                timestamp: Date.now(),
+                results: []
+            });
+            await manager.sendMessage('+33123456789', '+33111111111', 'Hello!');
+            expect(instance.sendMessage).toHaveBeenCalledWith('+33111111111', 'Hello!', {});
+        });
+        it('should throw error when sending from non-existent account', async () => {
+            await expect(manager.sendMessage('+33999999999', '+33111111111', 'Hello!')).rejects.toThrow('Account +33999999999 not found');
+        });
+        it('should send message with options', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            instance.sendMessage = jest.fn().mockResolvedValue({
+                timestamp: Date.now(),
+                results: []
+            });
+            const options = { attachments: ['file.jpg'] };
+            await manager.sendMessage('+33123456789', '+33111111111', 'Hello!', options);
+            expect(instance.sendMessage).toHaveBeenCalledWith('+33111111111', 'Hello!', options);
+        });
+    });
+    describe('Event Forwarding', () => {
+        it('should setup event forwarding on account addition', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            // Verify instance was created
+            expect(instance).toBeDefined();
+            expect(manager.hasAccount('+33123456789')).toBe(true);
+        });
+    });
+    describe('Status Information', () => {
+        it('should get status for specific account', async () => {
+            await manager.addAccount('+33123456789');
+            const status = manager.getStatus('+33123456789');
+            expect(status).toHaveProperty('account', '+33123456789');
+            expect(status).toHaveProperty('connected', false);
+            expect(status).toHaveProperty('lastActivity');
+            expect(status).toHaveProperty('uptime');
+        });
+        it('should return null for non-existent account status', () => {
+            const status = manager.getStatus('+33999999999');
+            expect(status).toBeNull();
+        });
+        it('should get status for all accounts', async () => {
+            await manager.addAccount('+33123456789');
+            await manager.addAccount('+33987654321');
+            const status = manager.getStatus();
+            expect(status.totalAccounts).toBe(2);
+            expect(status.connectedAccounts).toBe(0);
+            expect(status.accounts).toHaveLength(2);
+        });
+        it('should update connected count in status', async () => {
+            const instance = await manager.addAccount('+33123456789');
+            jest.spyOn(instance, 'connect').mockResolvedValue();
+            await manager.connect('+33123456789');
+            const status = manager.getStatus();
+            expect(status.connectedAccounts).toBe(1);
+        });
+    });
+    describe('Shutdown', () => {
+        it('should shutdown and cleanup all accounts', async () => {
+            const instance1 = await manager.addAccount('+33123456789');
+            const instance2 = await manager.addAccount('+33987654321');
+            instance1.connect = jest.fn().mockResolvedValue(undefined);
+            instance2.connect = jest.fn().mockResolvedValue(undefined);
+            instance1.disconnect = jest.fn().mockResolvedValue(undefined);
+            instance2.disconnect = jest.fn().mockResolvedValue(undefined);
+            await manager.connectAll();
+            await manager.shutdown();
+            expect(manager.getAccounts()).toHaveLength(0);
+        });
+    });
+});

package/dist/__tests__/SignalBot.additional.test.js

@@ -9,6 +9,8 @@ describe('SignalBot Additional Tests', () => {
     let bot;
     let mockConfig;
     beforeEach(() => {
+        // Use real timers for these tests
+        jest.useRealTimers();
         mockConfig = {
             phoneNumber: '+1234567890',
             admins: ['+0987654321'],
@@ -25,8 +27,11 @@ describe('SignalBot Additional Tests', () => {
     afterEach(async () => {
         if (bot) {
             await bot.stop();
-            // Wait for any pending async operations to complete
-            await new Promise(resolve => setTimeout(resolve, 100));
+            // Remove all listeners to prevent memory leaks
+            bot.removeAllListeners();
+            bot.getSignalCli().removeAllListeners();
+            // Wait a bit for any async operations to complete
+            await new Promise(resolve => process.nextTick(resolve));
         }
     });
     describe('Command Management', () => {
@@ -115,42 +120,57 @@ describe('SignalBot Additional Tests', () => {
     });
     describe('Message Sending', () => {
         test('should queue message for sending', async () => {
+            jest.useFakeTimers();
             bot = new SignalBot_1.SignalBot(mockConfig);
             const mockSignalCli = bot.getSignalCli();
             const sendMessageSpy = jest.spyOn(mockSignalCli, 'sendMessage').mockResolvedValue({
                 results: [{ type: 'SUCCESS' }],
                 timestamp: Date.now()
             });
-            await bot.sendMessage('+1111111111', 'Test message');
-            // Wait for queue to process
-            await new Promise(resolve => setTimeout(resolve, 150));
+            // Send message (queued)
+            const sendPromise = bot.sendMessage('+1111111111', 'Test message');
+            // Advance timers to process queue
+            jest.advanceTimersByTime(250);
+            await Promise.resolve(); // Let promises resolve
+            await sendPromise;
             expect(sendMessageSpy).toHaveBeenCalledWith('+1111111111', 'Test message');
+            jest.useRealTimers();
         });
         test('should queue reaction for sending', async () => {
+            jest.useFakeTimers();
             bot = new SignalBot_1.SignalBot(mockConfig);
             const mockSignalCli = bot.getSignalCli();
             const sendReactionSpy = jest.spyOn(mockSignalCli, 'sendReaction').mockResolvedValue({
                 results: [{ type: 'SUCCESS' }],
                 timestamp: Date.now()
             });
-            await bot.sendReaction('+1111111111', '+2222222222', 123456, '👍');
-            // Wait for queue to process
-            await new Promise(resolve => setTimeout(resolve, 150));
+            // Send reaction (queued)
+            const sendPromise = bot.sendReaction('+1111111111', '+2222222222', 123456, '👍');
+            // Advance timers to process queue
+            jest.advanceTimersByTime(250);
+            await Promise.resolve();
+            await sendPromise;
             expect(sendReactionSpy).toHaveBeenCalledWith('+1111111111', '+2222222222', 123456, '👍');
+            jest.useRealTimers();
         });
         test('should handle message with attachments', async () => {
+            jest.useFakeTimers();
             bot = new SignalBot_1.SignalBot(mockConfig);
             const mockSignalCli = bot.getSignalCli();
             const sendMessageSpy = jest.spyOn(mockSignalCli, 'sendMessage').mockResolvedValue({
                 results: [{ type: 'SUCCESS' }],
                 timestamp: Date.now()
             });
-            await bot.sendMessageWithAttachment('+1111111111', 'Message with files', ['file1.txt', 'file2.jpg']);
-            // Wait for queue to process
-            await new Promise(resolve => setTimeout(resolve, 150));
+            // Send message with attachment (queued)
+            const sendPromise = bot.sendMessageWithAttachment('+1111111111', 'Message with files', ['file1.txt', 'file2.jpg']);
+            // Advance timers to process queue and cleanup timer
+            jest.advanceTimersByTime(2500); // 250ms for queue + 2000ms for cleanup
+            await Promise.resolve();
+            await sendPromise;
             expect(sendMessageSpy).toHaveBeenCalledWith('+1111111111', 'Message with files', {
                 attachments: ['file1.txt', 'file2.jpg']
             });
+            jest.useRealTimers();
         });
     });
     describe('Configuration', () => {

package/dist/__tests__/SignalBot.test.js

@@ -17,7 +17,12 @@ describe('SignalBot', () => {
     afterEach(async () => {
         if (bot) {
             await bot.stop();
+            // Clean up all listeners
+            bot.removeAllListeners();
+            bot.getSignalCli().removeAllListeners();
         }
+        // Clear all timers
+        jest.clearAllTimers();
     });
     test('should create bot with minimal config', () => {
         bot = new SignalBot_1.SignalBot({

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

@@ -0,0 +1,5 @@
+/**
+ * Advanced Features Tests for SignalCli
+ * Tests for new features added for 100% signal-cli coverage
+ */
+export {};

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 {};