signal-sdk 0.0.8 → 0.0.9

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

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

package/dist/__tests__/SignalBot.test.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalBot_1 = require("../SignalBot");
+describe('SignalBot', () => {
+    let bot;
+    let mockConfig;
+    beforeEach(() => {
+        mockConfig = {
+            phoneNumber: '+1234567890',
+            admins: ['+0987654321'],
+            group: {
+                name: 'Test Bot Group',
+                createIfNotExists: false
+            }
+        };
+    });
+    afterEach(async () => {
+        if (bot) {
+            await bot.stop();
+        }
+    });
+    test('should create bot with minimal config', () => {
+        bot = new SignalBot_1.SignalBot({
+            phoneNumber: '+1234567890'
+        });
+        expect(bot).toBeDefined();
+        expect(bot.isAdmin('+1234567890')).toBe(false);
+    });
+    test('should create bot with full config', () => {
+        bot = new SignalBot_1.SignalBot(mockConfig);
+        expect(bot).toBeDefined();
+        expect(bot.isAdmin('+0987654321')).toBe(true);
+        expect(bot.getBotGroupId()).toBeNull();
+    });
+    test('should add and remove commands', () => {
+        bot = new SignalBot_1.SignalBot(mockConfig);
+        const testCommand = {
+            name: 'test',
+            description: 'Test command',
+            handler: jest.fn()
+        };
+        bot.addCommand(testCommand);
+        const commands = bot.getCommands();
+        expect(commands.some((cmd) => cmd.name === 'test')).toBe(true);
+        const removed = bot.removeCommand('test');
+        expect(removed).toBe(true);
+        const commandsAfter = bot.getCommands();
+        expect(commandsAfter.some((cmd) => cmd.name === 'test')).toBe(false);
+    });
+    test('should have default commands', () => {
+        bot = new SignalBot_1.SignalBot(mockConfig);
+        const commands = bot.getCommands();
+        const commandNames = commands.map((cmd) => cmd.name);
+        expect(commandNames).toContain('help');
+        expect(commandNames).toContain('stats');
+        expect(commandNames).toContain('ping');
+        expect(commandNames).toContain('info');
+    });
+    test('should emit ready event when started', (done) => {
+        bot = new SignalBot_1.SignalBot({
+            phoneNumber: '+1234567890',
+            group: {
+                name: 'Test Group',
+                createIfNotExists: false
+            }
+        });
+        // Mock SignalCli methods to avoid actual Signal operations
+        const mockSignalCli = bot.getSignalCli();
+        jest.spyOn(mockSignalCli, 'listDevices').mockResolvedValue([
+            { id: 1, name: 'Test Device', created: Date.now(), lastSeen: Date.now() }
+        ]);
+        jest.spyOn(mockSignalCli, 'startDaemon').mockImplementation(() => { });
+        jest.spyOn(mockSignalCli, 'connect').mockResolvedValue(undefined);
+        jest.spyOn(mockSignalCli, 'on').mockReturnValue(mockSignalCli);
+        bot.on('ready', () => {
+            expect(true).toBe(true);
+            done();
+        });
+        bot.start().catch(done);
+    });
+    test('should get stats', () => {
+        bot = new SignalBot_1.SignalBot(mockConfig);
+        const stats = bot.getStats();
+        expect(stats).toHaveProperty('messagesReceived');
+        expect(stats).toHaveProperty('commandsExecuted');
+        expect(stats).toHaveProperty('startTime');
+        expect(stats).toHaveProperty('lastActivity');
+        expect(stats).toHaveProperty('activeUsers');
+        expect(stats.messagesReceived).toBe(0);
+        expect(stats.commandsExecuted).toBe(0);
+        expect(stats.activeUsers).toBe(0);
+    });
+    test('should handle admin permissions', () => {
+        bot = new SignalBot_1.SignalBot({
+            phoneNumber: '+1234567890',
+            admins: ['+0987654321', '+1111111111']
+        });
+        expect(bot.isAdmin('+0987654321')).toBe(true);
+        expect(bot.isAdmin('+1111111111')).toBe(true);
+        expect(bot.isAdmin('+9999999999')).toBe(false);
+    });
+});

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

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

package/dist/__tests__/SignalCli.test.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+const child_process_1 = require("child_process");
+jest.mock('child_process');
+describe('SignalCli', () => {
+    let signalCli;
+    let mockProcess;
+    beforeEach(() => {
+        mockProcess = {
+            stdout: {
+                on: jest.fn(),
+                once: jest.fn(),
+            },
+            stderr: {
+                on: jest.fn(),
+            },
+            stdin: {
+                write: jest.fn(),
+            },
+            on: jest.fn(),
+            once: jest.fn(),
+            kill: jest.fn(),
+        };
+        const spawnMock = child_process_1.spawn;
+        spawnMock.mockReturnValue(mockProcess);
+        signalCli = new SignalCli_1.SignalCli('signal-cli', '+1234567890');
+    });
+    it('should be defined', () => {
+        expect(SignalCli_1.SignalCli).toBeDefined();
+    });
+    it('should connect to JSON-RPC mode', async () => {
+        // Mock the stdout data event to resolve connect
+        mockProcess.stdout.once.mockImplementation((event, callback) => {
+            if (event === 'data') {
+                callback();
+            }
+        });
+        await signalCli.connect();
+        // On Windows, spawn may use cmd.exe /c, so we check the arguments more flexibly
+        const spawnCalls = child_process_1.spawn.mock.calls;
+        expect(spawnCalls).toHaveLength(1);
+        const [command, args] = spawnCalls[0];
+        if (process.platform === 'win32') {
+            // On Windows, expect cmd.exe with /c and the actual command
+            expect(command).toBe('cmd.exe');
+            expect(args).toEqual(['/c', 'signal-cli', '-a', '+1234567890', 'jsonRpc']);
+        }
+        else {
+            // On Unix-like systems, expect direct command
+            expect(command).toBe('signal-cli');
+            expect(args).toEqual(['-a', '+1234567890', 'jsonRpc']);
+        }
+    });
+    it('should send JSON-RPC request for sendMessage', async () => {
+        // Mock sendJsonRpcRequest directly
+        const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            .mockResolvedValue({ results: [{ type: 'SUCCESS' }], timestamp: 123456 });
+        await signalCli.sendMessage('+10987654321', 'Hello, world!');
+        expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', {
+            message: 'Hello, world!',
+            account: '+1234567890',
+            recipients: ['+10987654321'],
+        });
+    });
+    it('should disconnect properly', async () => {
+        // Connect first
+        mockProcess.stdout.once.mockImplementation((event, callback) => {
+            if (event === 'data') {
+                setTimeout(callback, 0);
+            }
+        });
+        await signalCli.connect();
+        // Now disconnect
+        signalCli.disconnect();
+        expect(mockProcess.kill).toHaveBeenCalled();
+    });
+    // Test new features
+    describe('New Features', () => {
+        beforeEach(() => {
+            // Mock sendJsonRpcRequest for all tests
+            jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
+        });
+        it('should remove contact', async () => {
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue({});
+            await signalCli.removeContact('+1234567890', { forget: true });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('removeContact', {
+                account: '+1234567890',
+                recipient: '+1234567890',
+                forget: true
+            });
+        });
+        it('should get user status', async () => {
+            const mockResponse = {
+                recipients: [
+                    { number: '+1234567890', isRegistered: true, uuid: 'test-uuid' }
+                ]
+            };
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockResponse);
+            const result = await signalCli.getUserStatus(['+1234567890']);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getUserStatus', {
+                account: '+1234567890',
+                recipients: ['+1234567890']
+            });
+            expect(result).toEqual([
+                { number: '+1234567890', isRegistered: true, uuid: 'test-uuid', username: undefined }
+            ]);
+        });
+        it('should send payment notification', async () => {
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue({ timestamp: 123456 });
+            await signalCli.sendPaymentNotification('+1234567890', {
+                receipt: 'base64-receipt',
+                note: 'Payment for coffee'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPaymentNotification', {
+                account: '+1234567890',
+                recipient: '+1234567890',
+                receipt: 'base64-receipt',
+                note: 'Payment for coffee'
+            });
+        });
+        it('should upload sticker pack', async () => {
+            const mockResponse = {
+                packId: 'pack-id',
+                packKey: 'pack-key',
+                installUrl: 'https://signal.org/stickers/pack-id'
+            };
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockResponse);
+            const result = await signalCli.uploadStickerPack({
+                path: '/path/to/manifest.json'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('uploadStickerPack', {
+                account: '+1234567890',
+                path: '/path/to/manifest.json'
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it('should submit rate limit challenge', async () => {
+            const mockResponse = {
+                success: true,
+                message: 'Challenge accepted'
+            };
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockResponse);
+            const result = await signalCli.submitRateLimitChallenge('challenge-token', 'captcha-token');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('submitRateLimitChallenge', {
+                account: '+1234567890',
+                challenge: 'challenge-token',
+                captcha: 'captcha-token'
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it('should start change number', async () => {
+            const mockResponse = {
+                session: 'change-session-id',
+                challenge: 'challenge-token'
+            };
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockResponse);
+            const result = await signalCli.startChangeNumber('+1987654321');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
+                account: '+1234567890',
+                number: '+1987654321',
+                voice: false
+            });
+            expect(result).toEqual({
+                session: 'change-session-id',
+                newNumber: '+1987654321',
+                challenge: 'challenge-token'
+            });
+        });
+        it('should finish change number', async () => {
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue({});
+            await signalCli.finishChangeNumber('123456', 'pin-code');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('finishChangeNumber', {
+                account: '+1234567890',
+                code: '123456',
+                pin: 'pin-code'
+            });
+        });
+    });
+    // Test cross-platform path detection
+    describe('Cross-platform compatibility', () => {
+        it('should use correct executable path based on platform', () => {
+            // Test Windows path
+            const originalPlatform = process.platform;
+            // Mock Windows
+            Object.defineProperty(process, 'platform', { value: 'win32' });
+            const windowsSignal = new SignalCli_1.SignalCli('+1234567890');
+            expect(windowsSignal.signalCliPath).toContain('signal-cli.bat');
+            // Mock Linux
+            Object.defineProperty(process, 'platform', { value: 'linux' });
+            const linuxSignal = new SignalCli_1.SignalCli('+1234567890');
+            expect(linuxSignal.signalCliPath).toContain('signal-cli');
+            expect(linuxSignal.signalCliPath).not.toContain('.bat');
+            // Mock macOS
+            Object.defineProperty(process, 'platform', { value: 'darwin' });
+            const macSignal = new SignalCli_1.SignalCli('+1234567890');
+            expect(macSignal.signalCliPath).toContain('signal-cli');
+            expect(macSignal.signalCliPath).not.toContain('.bat');
+            // Restore original platform
+            Object.defineProperty(process, 'platform', { value: originalPlatform });
+        });
+        it('should spawn correct command based on platform', async () => {
+            const originalPlatform = process.platform;
+            // Test Windows spawning
+            Object.defineProperty(process, 'platform', { value: 'win32' });
+            const windowsSignal = new SignalCli_1.SignalCli('test-path.bat', '+1234567890');
+            mockProcess.stdout.once.mockImplementation((event, callback) => {
+                if (event === 'data')
+                    callback();
+            });
+            await windowsSignal.connect();
+            const windowsCalls = child_process_1.spawn.mock.calls;
+            const lastCall = windowsCalls[windowsCalls.length - 1];
+            expect(lastCall[0]).toBe('cmd.exe');
+            expect(lastCall[1]).toEqual(['/c', '"test-path.bat"', '-a', '+1234567890', 'jsonRpc']);
+            // Test Unix spawning
+            Object.defineProperty(process, 'platform', { value: 'linux' });
+            const linuxSignal = new SignalCli_1.SignalCli('test-path', '+1234567890');
+            await linuxSignal.connect();
+            const linuxCalls = child_process_1.spawn.mock.calls;
+            const lastLinuxCall = linuxCalls[linuxCalls.length - 1];
+            expect(lastLinuxCall[0]).toBe('test-path');
+            expect(lastLinuxCall[1]).toEqual(['-a', '+1234567890', 'jsonRpc']);
+            // Restore original platform
+            Object.defineProperty(process, 'platform', { value: originalPlatform });
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { SignalCli } from './SignalCli';
+export { SignalBot } from './SignalBot';
+export * from './interfaces';

package/dist/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalBot = exports.SignalCli = void 0;
+var SignalCli_1 = require("./SignalCli");
+Object.defineProperty(exports, "SignalCli", { enumerable: true, get: function () { return SignalCli_1.SignalCli; } });
+var SignalBot_1 = require("./SignalBot");
+Object.defineProperty(exports, "SignalBot", { enumerable: true, get: function () { return SignalBot_1.SignalBot; } });
+__exportStar(require("./interfaces"), exports);