signal-sdk 0.1.2 → 0.1.3

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

@@ -10,7 +10,8 @@ describe('SignalCli Advanced Features', () => {
     let sendJsonRpcRequestSpy;
     beforeEach(() => {
         signalCli = new SignalCli_1.SignalCli('+1234567890');
-        sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+        sendJsonRpcRequestSpy = jest
+            .spyOn(signalCli, 'sendJsonRpcRequest')
             .mockResolvedValue({ timestamp: Date.now(), results: [] });
     });
     afterEach(() => {
@@ -19,37 +20,29 @@ describe('SignalCli Advanced Features', () => {
     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' }
-                ]
+                textStyles: [{ start: 6, length: 6, style: 'BOLD' }],
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'Hello *bold* text',
-                textStyles: [
-                    { start: 6, length: 6, style: 'BOLD' }
-                ]
+                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' }
-                ]
+                mentions: [{ start: 6, length: 5, number: '+33111111111' }],
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'Hello @John',
-                mentions: [
-                    { start: 6, length: 5, number: '+33111111111' }
-                ]
+                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'
+                previewUrl: 'https://example.com',
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'Check this out',
-                previewUrl: 'https://example.com'
+                previewUrl: 'https://example.com',
             }));
         });
         it('should send message with quote and advanced fields', async () => {
@@ -59,8 +52,8 @@ describe('SignalCli Advanced Features', () => {
                     author: '+33111111111',
                     text: 'Original message',
                     mentions: [{ start: 0, length: 5, number: '+33222222222' }],
-                    textStyles: [{ start: 0, length: 8, style: 'BOLD' }]
-                }
+                    textStyles: [{ start: 0, length: 8, style: 'BOLD' }],
+                },
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'I agree!',
@@ -68,45 +61,45 @@ describe('SignalCli Advanced Features', () => {
                 quoteAuthor: '+33111111111',
                 quoteMessage: 'Original message',
                 quoteMentions: [{ start: 0, length: 5, number: '+33222222222' }],
-                quoteTextStyles: [{ start: 0, length: 8, style: 'BOLD' }]
+                quoteTextStyles: [{ start: 0, length: 8, style: 'BOLD' }],
             }));
         });
         it('should send message edit', async () => {
             await signalCli.sendMessage('+33123456789', 'Corrected text', {
-                editTimestamp: 123456789
+                editTimestamp: 123456789,
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'Corrected text',
-                editTimestamp: 123456789
+                editTimestamp: 123456789,
             }));
         });
         it('should send reply to story', async () => {
             await signalCli.sendMessage('+33123456789', 'Nice story!', {
                 storyTimestamp: 123456789,
-                storyAuthor: '+33111111111'
+                storyAuthor: '+33111111111',
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'Nice story!',
                 storyTimestamp: 123456789,
-                storyAuthor: '+33111111111'
+                storyAuthor: '+33111111111',
             }));
         });
         it('should send message with noteToSelf flag', async () => {
             await signalCli.sendMessage('+1234567890', 'Note to myself', {
-                noteToSelf: true
+                noteToSelf: true,
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'Note to myself',
-                noteToSelf: true
+                noteToSelf: true,
             }));
         });
         it('should send message with endSession flag', async () => {
             await signalCli.sendMessage('+33123456789', 'Goodbye', {
-                endSession: true
+                endSession: true,
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'Goodbye',
-                endSession: true
+                endSession: true,
             }));
         });
     });
@@ -116,12 +109,12 @@ describe('SignalCli Advanced Features', () => {
                 {
                     timestamp: 123456789,
                     source: '+33123456789',
-                    dataMessage: { message: 'Hello!' }
-                }
+                    dataMessage: { message: 'Hello!' },
+                },
             ]);
             const messages = await signalCli.receive();
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
-                account: '+1234567890'
+                account: '+1234567890',
             }));
             expect(messages).toHaveLength(1);
             expect(messages[0].text).toBe('Hello!');
@@ -130,32 +123,32 @@ describe('SignalCli Advanced Features', () => {
             sendJsonRpcRequestSpy.mockResolvedValue([]);
             await signalCli.receive({ timeout: 10 });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
-                timeout: 10
+                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
+                maxMessages: 5,
             }));
         });
         it('should receive messages with ignoreAttachments', async () => {
             await signalCli.receive({ ignoreAttachments: true });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
-                ignoreAttachments: true
+                ignoreAttachments: true,
             }));
         });
         it('should receive messages with ignoreStories', async () => {
             await signalCli.receive({ ignoreStories: true });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
-                ignoreStories: true
+                ignoreStories: true,
             }));
         });
         it('should receive messages with sendReadReceipts', async () => {
             await signalCli.receive({ sendReadReceipts: true });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('receive', expect.objectContaining({
-                sendReadReceipts: true
+                sendReadReceipts: true,
             }));
         });
         it('should handle empty message array', async () => {
@@ -168,11 +161,11 @@ describe('SignalCli Advanced Features', () => {
         it('should set username', async () => {
             sendJsonRpcRequestSpy.mockResolvedValue({
                 username: 'myuser.123',
-                usernameLink: 'https://signal.me/#myuser.123'
+                usernameLink: 'https://signal.me/#myuser.123',
             });
             const result = await signalCli.setUsername('myuser');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
-                username: 'myuser'
+                username: 'myuser',
             }));
             expect(result.success).toBe(true);
             expect(result.username).toBe('myuser.123');
@@ -181,7 +174,7 @@ describe('SignalCli Advanced Features', () => {
             sendJsonRpcRequestSpy.mockResolvedValue({});
             const result = await signalCli.deleteUsername();
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
-                deleteUsername: true
+                deleteUsername: true,
             }));
             expect(result.success).toBe(true);
         });
@@ -192,12 +185,12 @@ describe('SignalCli Advanced Features', () => {
                 {
                     number: '+33123456789',
                     safetyNumber: '12345 67890 12345 67890 12345 67890',
-                    trustLevel: 'TRUSTED'
-                }
+                    trustLevel: 'TRUSTED',
+                },
             ]);
             const safetyNumber = await signalCli.getSafetyNumber('+33123456789');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listIdentities', expect.objectContaining({
-                number: '+33123456789'
+                number: '+33123456789',
             }));
             expect(safetyNumber).toBe('12345 67890 12345 67890 12345 67890');
         });
@@ -212,15 +205,15 @@ describe('SignalCli Advanced Features', () => {
                 {
                     number: '+33123456789',
                     safetyNumber: '12345 67890 12345 67890 12345 67890',
-                    trustLevel: 'TRUSTED'
-                }
+                    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'
+                recipient: '+33123456789',
             }));
         });
         it('should fail to verify incorrect safety number', async () => {
@@ -228,8 +221,8 @@ describe('SignalCli Advanced Features', () => {
                 {
                     number: '+33123456789',
                     safetyNumber: '12345 67890 12345 67890 12345 67890',
-                    trustLevel: 'TRUSTED'
-                }
+                    trustLevel: 'TRUSTED',
+                },
             ]);
             const verified = await signalCli.verifySafetyNumber('+33123456789', '99999 99999 99999 99999 99999 99999');
             expect(verified).toBe(false);
@@ -239,15 +232,11 @@ describe('SignalCli Advanced Features', () => {
                 { number: '+33111111111', trustLevel: 'TRUSTED' },
                 { number: '+33222222222', trustLevel: 'UNTRUSTED' },
                 { number: '+33333333333', trustLevel: 'TRUST_ON_FIRST_USE' },
-                { number: '+33444444444' }
+                { number: '+33444444444' },
             ]);
             const untrusted = await signalCli.listUntrustedIdentities();
             expect(untrusted).toHaveLength(3);
-            expect(untrusted.map(i => i.number)).toEqual([
-                '+33222222222',
-                '+33333333333',
-                '+33444444444'
-            ]);
+            expect(untrusted.map((i) => i.number)).toEqual(['+33222222222', '+33333333333', '+33444444444']);
         });
     });
     describe('Advanced Group Management', () => {
@@ -257,23 +246,23 @@ describe('SignalCli Advanced Features', () => {
                 {
                     groupId: 'group123==',
                     name: 'Test Group',
-                    groupInviteLink: 'https://signal.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']
+                recipients: ['+33123456789'],
             }));
         });
         it('should throw error when group has no invite link', async () => {
             sendJsonRpcRequestSpy.mockResolvedValue([
                 {
                     groupId: 'group123==',
-                    name: 'Test Group'
-                }
+                    name: 'Test Group',
+                },
             ]);
             await expect(signalCli.sendGroupInviteLink('group123==', '+33123456789')).rejects.toThrow('Group not found or does not have an invite link');
         });
@@ -281,14 +270,14 @@ describe('SignalCli Advanced Features', () => {
             await signalCli.setBannedMembers('group123==', ['+33111111111', '+33222222222']);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateGroup', expect.objectContaining({
                 groupId: 'group123==',
-                banMembers: ['+33111111111', '+33222222222']
+                banMembers: ['+33111111111', '+33222222222'],
             }));
         });
         it('should reset group link', async () => {
             await signalCli.resetGroupLink('group123==');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateGroup', expect.objectContaining({
                 groupId: 'group123==',
-                resetLink: true
+                resetLink: true,
             }));
         });
     });

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+const net = __importStar(require("net"));
+const http = __importStar(require("http"));
+const events_1 = require("events");
+jest.mock('net');
+jest.mock('http');
+jest.mock('https');
+describe('SignalCli Connections', () => {
+    let signalCli;
+    let mockSocket;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockSocket = new events_1.EventEmitter();
+        mockSocket.write = jest.fn();
+        mockSocket.destroy = jest.fn();
+        net.createConnection.mockReturnValue(mockSocket);
+    });
+    it('should connect via Unix socket', async () => {
+        signalCli = new SignalCli_1.SignalCli('+1234567890', undefined, {
+            daemonMode: 'unix-socket',
+            socketPath: '/tmp/test.sock'
+        });
+        const connectPromise = signalCli.connect();
+        setImmediate(() => mockSocket.emit('connect'));
+        await connectPromise;
+        expect(net.createConnection).toHaveBeenCalledWith('/tmp/test.sock');
+    });
+    it('should connect via TCP', async () => {
+        signalCli = new SignalCli_1.SignalCli('+1234567890', undefined, {
+            daemonMode: 'tcp',
+            tcpHost: '1.2.3.4',
+            tcpPort: 1234
+        });
+        const connectPromise = signalCli.connect();
+        setImmediate(() => mockSocket.emit('connect'));
+        await connectPromise;
+        expect(net.createConnection).toHaveBeenCalledWith(1234, '1.2.3.4');
+    });
+    it('should connect via HTTP', async () => {
+        const mockRes = new events_1.EventEmitter();
+        mockRes.on = jest.fn().mockImplementation((event, cb) => {
+            if (event === 'data')
+                cb(JSON.stringify({ jsonrpc: '2.0', result: 'ok', id: '1' }));
+            if (event === 'end')
+                cb();
+            return mockRes;
+        });
+        const mockReq = new events_1.EventEmitter();
+        mockReq.write = jest.fn();
+        mockReq.end = jest.fn();
+        mockReq.setTimeout = jest.fn();
+        http.request.mockImplementation((url, opts, cb) => {
+            setImmediate(() => cb(mockRes));
+            return mockReq;
+        });
+        signalCli = new SignalCli_1.SignalCli('+1234567890', undefined, {
+            daemonMode: 'http',
+            httpBaseUrl: 'http://localhost:8080'
+        });
+        await signalCli.connect();
+        expect(http.request).toHaveBeenCalled();
+    });
+    it('should handle socket data and errors', async () => {
+        signalCli = new SignalCli_1.SignalCli('+1234567890', undefined, {
+            daemonMode: 'tcp'
+        });
+        const connectPromise = signalCli.connect();
+        setImmediate(() => mockSocket.emit('connect'));
+        await connectPromise;
+        const errorSpy = jest.fn();
+        signalCli.on('error', errorSpy);
+        mockSocket.emit('data', Buffer.from('invalid json\n'));
+        expect(errorSpy).toHaveBeenCalled();
+    });
+});

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

@@ -16,23 +16,17 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
     });
     describe('Complete Messaging Workflow', () => {
         it('should send message with full options and handle response', async () => {
-            signal.sendJsonRpcRequest = jest.fn()
-                .mockResolvedValue(mockSendResponse);
+            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' },
-                ],
+                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);
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue(mockSendResponse);
             const result = await signal.sendMessage('+33987654321', 'Reply', {
                 quote: {
                     timestamp: 1234567890,
@@ -60,7 +54,8 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
                     blocked: false,
                 },
             ];
-            signal.sendJsonRpcRequest = jest.fn()
+            signal.sendJsonRpcRequest = jest
+                .fn()
                 .mockResolvedValueOnce(mockContacts)
                 .mockResolvedValueOnce(undefined)
                 .mockResolvedValueOnce([mockContacts[0]]);
@@ -80,10 +75,7 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
                 isMember: true,
                 isBlocked: false,
                 messageExpirationTime: 0,
-                members: [
-                    { number: '+33111111111' },
-                    { number: '+33222222222' },
-                ],
+                members: [{ number: '+33111111111' }, { number: '+33222222222' }],
                 pendingMembers: [],
                 requestingMembers: [],
                 admins: [{ number: '+33111111111' }],
@@ -93,17 +85,15 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
                 permissionSendMessage: 'EVERY_MEMBER',
                 groupInviteLink: 'https://signal.group/test',
             };
-            signal.sendJsonRpcRequest = jest.fn()
+            signal.sendJsonRpcRequest = jest
+                .fn()
                 .mockResolvedValueOnce([mockGroup])
                 .mockResolvedValueOnce(undefined)
                 .mockResolvedValueOnce(mockSendResponse)
                 .mockResolvedValueOnce([
                 {
                     ...mockGroup,
-                    members: [
-                        ...mockGroup.members,
-                        { number: '+33333333333' },
-                    ],
+                    members: [...mockGroup.members, { number: '+33333333333' }],
                 },
             ]);
             const groups = await signal.getGroupsWithDetails();
@@ -120,11 +110,14 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
     describe('Identity Management Workflow', () => {
         it('should verify safety number before sending', async () => {
             const mockSafetyNumber = '12345 67890 12345 67890 12345 67890';
-            const mockIdentities = [{
+            const mockIdentities = [
+                {
                     safetyNumber: mockSafetyNumber,
                     number: '+33987654321',
-                }];
-            signal.sendJsonRpcRequest = jest.fn()
+                },
+            ];
+            signal.sendJsonRpcRequest = jest
+                .fn()
                 .mockResolvedValueOnce(mockIdentities) // listIdentities
                 .mockResolvedValueOnce(mockIdentities) // listIdentities again for verify
                 .mockResolvedValueOnce(undefined) // trust
@@ -138,7 +131,8 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
     });
     describe('Username Management Workflow', () => {
         it('should manage username lifecycle', async () => {
-            signal.sendJsonRpcRequest = jest.fn()
+            signal.sendJsonRpcRequest = jest
+                .fn()
                 .mockResolvedValueOnce({ username: 'alice.01' })
                 .mockResolvedValueOnce(mockSendResponse)
                 .mockResolvedValueOnce(undefined);
@@ -176,7 +170,8 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
                     },
                 },
             ];
-            signal.sendJsonRpcRequest = jest.fn()
+            signal.sendJsonRpcRequest = jest
+                .fn()
                 .mockResolvedValueOnce(mockMessages)
                 .mockResolvedValueOnce(mockSendResponse)
                 .mockResolvedValueOnce(mockSendResponse);
@@ -188,7 +183,8 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
             if (msg0.envelope && msg0.envelope.source) {
                 await signal.sendMessage(msg0.envelope.source, 'Hello back!');
             }
-            if (msg1.envelope && msg1.envelope.dataMessage &&
+            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!');
@@ -200,7 +196,8 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
     describe('Multi-Step Group Operations', () => {
         it('should create group, add members, and send announcement', async () => {
             const mockGroupId = 'newgroup123==';
-            signal.sendJsonRpcRequest = jest.fn()
+            signal.sendJsonRpcRequest = jest
+                .fn()
                 .mockResolvedValueOnce({ groupId: mockGroupId })
                 .mockResolvedValueOnce(undefined)
                 .mockResolvedValueOnce(undefined)
@@ -220,7 +217,8 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
     });
     describe('Error Handling in Workflows', () => {
         it('should handle errors gracefully in message sending workflow', async () => {
-            signal.sendJsonRpcRequest = jest.fn()
+            signal.sendJsonRpcRequest = jest
+                .fn()
                 .mockRejectedValueOnce(new Error('Network error'))
                 .mockResolvedValueOnce(mockSendResponse);
             await expect(signal.sendMessage('+33987654321', 'Test')).rejects.toThrow('Network error');
@@ -228,12 +226,10 @@ describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
             expect(result.timestamp).toBeDefined();
         });
         it('should handle non-existent group in workflow', async () => {
-            signal.sendJsonRpcRequest = jest.fn()
-                .mockResolvedValue([]);
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue([]);
             const groups = await signal.getGroupsWithDetails();
             expect(groups).toHaveLength(0);
-            signal.sendJsonRpcRequest = jest.fn()
-                .mockRejectedValue(new Error('Group not found'));
+            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.events.test.d.ts

@@ -0,0 +1 @@
+export {};