signal-sdk 0.1.0 → 0.1.2

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

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Tests for enhanced parsing functionality (Phase 5)
+ * Tests profile and group data parsing methods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+describe('SignalCli - Enhanced Parsing (Phase 5)', () => {
+    let signal;
+    beforeEach(() => {
+        signal = new SignalCli_1.SignalCli('+33123456789');
+        // Mock sendJsonRpcRequest to avoid actual signal-cli calls
+        signal.sendJsonRpcRequest = jest.fn();
+    });
+    describe('parseContactProfile', () => {
+        it('should parse contact with full profile data', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John Doe',
+                uuid: 'test-uuid',
+                blocked: false,
+                givenName: 'John',
+                familyName: 'Doe',
+                mobileCoinAddress: 'mc1_test_address_123',
+                profileName: 'John Doe',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.givenName).toBe('John');
+            expect(parsed.familyName).toBe('Doe');
+            expect(parsed.mobileCoinAddress).toBe('mc1_test_address_123');
+            expect(parsed.profileName).toBe('John Doe');
+        });
+        it('should build profileName from givenName and familyName if missing', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John Doe',
+                uuid: 'test-uuid',
+                blocked: false,
+                givenName: 'John',
+                familyName: 'Doe',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.profileName).toBe('John Doe');
+        });
+        it('should use givenName as profileName if no familyName', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John',
+                uuid: 'test-uuid',
+                blocked: false,
+                givenName: 'John',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.profileName).toBe('John');
+        });
+        it('should handle contact with minimal data', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'Unknown',
+                blocked: false,
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.givenName).toBeUndefined();
+            expect(parsed.familyName).toBeUndefined();
+            expect(parsed.mobileCoinAddress).toBeUndefined();
+        });
+        it('should preserve additional contact fields', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John Doe',
+                uuid: 'test-uuid',
+                blocked: true,
+                profileAvatar: 'avatar.jpg',
+                color: 'blue',
+                archived: true,
+                mutedUntil: 123456789,
+                hideStory: true,
+                givenName: 'John',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.blocked).toBe(true);
+            expect(parsed.profileAvatar).toBe('avatar.jpg');
+            expect(parsed.color).toBe('blue');
+            expect(parsed.archived).toBe(true);
+            expect(parsed.mutedUntil).toBe(123456789);
+            expect(parsed.hideStory).toBe(true);
+        });
+    });
+    describe('parseGroupDetails', () => {
+        it('should parse group with full membership data', () => {
+            const group = {
+                groupId: 'group123==',
+                name: 'Test Group',
+                description: 'A test group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [
+                    { number: '+33111111111' },
+                    { number: '+33222222222' },
+                ],
+                pendingMembers: [
+                    { number: '+33333333333' },
+                ],
+                requestingMembers: [],
+                admins: [
+                    { number: '+33111111111' },
+                ],
+                banned: [
+                    { number: '+33444444444' },
+                ],
+                permissionAddMember: 'ONLY_ADMINS',
+                permissionEditDetails: 'ONLY_ADMINS',
+                permissionSendMessage: 'EVERY_MEMBER',
+                groupInviteLink: 'https://signal.group/test',
+            };
+            const parsed = signal.parseGroupDetails(group);
+            expect(parsed.pendingMembers).toHaveLength(1);
+            expect(parsed.pendingMembers[0].number).toBe('+33333333333');
+            expect(parsed.banned).toHaveLength(1);
+            expect(parsed.banned[0].number).toBe('+33444444444');
+            expect(parsed.inviteLink).toBe('https://signal.group/test');
+            expect(parsed.groupInviteLink).toBe('https://signal.group/test');
+        });
+        it('should normalize inviteLink field', () => {
+            const group1 = {
+                groupId: 'group123==',
+                name: 'Test Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [],
+                banned: [],
+                permissionAddMember: 'EVERY_MEMBER',
+                permissionEditDetails: 'EVERY_MEMBER',
+                permissionSendMessage: 'EVERY_MEMBER',
+                groupInviteLink: 'https://signal.group/test1',
+            };
+            const parsed1 = signal.parseGroupDetails(group1);
+            expect(parsed1.inviteLink).toBe('https://signal.group/test1');
+            expect(parsed1.groupInviteLink).toBe('https://signal.group/test1');
+            const group2 = {
+                ...group1,
+                groupInviteLink: undefined,
+                inviteLink: 'https://signal.group/test2',
+            };
+            const parsed2 = signal.parseGroupDetails(group2);
+            expect(parsed2.inviteLink).toBe('https://signal.group/test2');
+            expect(parsed2.groupInviteLink).toBe('https://signal.group/test2');
+        });
+        it('should ensure membership arrays exist', () => {
+            const group = {
+                groupId: 'group123==',
+                name: 'Minimal Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [],
+                banned: [],
+                permissionAddMember: 'EVERY_MEMBER',
+                permissionEditDetails: 'EVERY_MEMBER',
+                permissionSendMessage: 'EVERY_MEMBER',
+            };
+            const parsed = signal.parseGroupDetails(group);
+            expect(Array.isArray(parsed.members)).toBe(true);
+            expect(Array.isArray(parsed.pendingMembers)).toBe(true);
+            expect(Array.isArray(parsed.requestingMembers)).toBe(true);
+            expect(Array.isArray(parsed.admins)).toBe(true);
+            expect(Array.isArray(parsed.banned)).toBe(true);
+        });
+        it('should preserve group permissions', () => {
+            const group = {
+                groupId: 'group123==',
+                name: 'Restricted Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 3600,
+                members: [],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [],
+                banned: [],
+                permissionAddMember: 'ONLY_ADMINS',
+                permissionEditDetails: 'ONLY_ADMINS',
+                permissionSendMessage: 'ONLY_ADMINS',
+            };
+            const parsed = signal.parseGroupDetails(group);
+            expect(parsed.permissionAddMember).toBe('ONLY_ADMINS');
+            expect(parsed.permissionEditDetails).toBe('ONLY_ADMINS');
+            expect(parsed.permissionSendMessage).toBe('ONLY_ADMINS');
+            expect(parsed.messageExpirationTime).toBe(3600);
+        });
+    });
+    describe('getContactsWithProfiles', () => {
+        it('should return enriched contacts list', async () => {
+            const mockContacts = [
+                {
+                    number: '+33111111111',
+                    name: 'Alice',
+                    blocked: false,
+                    givenName: 'Alice',
+                    familyName: 'Smith',
+                },
+                {
+                    number: '+33222222222',
+                    name: 'Bob',
+                    blocked: false,
+                    givenName: 'Bob',
+                    mobileCoinAddress: 'mc1_bob',
+                },
+            ];
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue(mockContacts);
+            const enriched = await signal.getContactsWithProfiles();
+            expect(enriched).toHaveLength(2);
+            expect(enriched[0].profileName).toBe('Alice Smith');
+            expect(enriched[1].profileName).toBe('Bob');
+            expect(enriched[1].mobileCoinAddress).toBe('mc1_bob');
+        });
+    });
+    describe('getGroupsWithDetails', () => {
+        it('should return enriched groups list', async () => {
+            const mockGroups = [
+                {
+                    groupId: 'group1==',
+                    name: 'Group 1',
+                    isMember: true,
+                    isBlocked: false,
+                    messageExpirationTime: 0,
+                    members: [{ number: '+33111111111' }],
+                    pendingMembers: [{ number: '+33222222222' }],
+                    requestingMembers: [],
+                    admins: [{ number: '+33111111111' }],
+                    banned: [],
+                    permissionAddMember: 'EVERY_MEMBER',
+                    permissionEditDetails: 'EVERY_MEMBER',
+                    permissionSendMessage: 'EVERY_MEMBER',
+                    groupInviteLink: 'https://signal.group/group1',
+                },
+            ];
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue(mockGroups);
+            const enriched = await signal.getGroupsWithDetails();
+            expect(enriched).toHaveLength(1);
+            expect(enriched[0].inviteLink).toBe('https://signal.group/group1');
+            expect(enriched[0].pendingMembers).toHaveLength(1);
+        });
+        it('should support list options', async () => {
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue([]);
+            await signal.getGroupsWithDetails({ detailed: true });
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledWith('listGroups', expect.objectContaining({ detailed: true }));
+        });
+    });
+});

package/dist/__tests__/SignalCli.test.js

@@ -155,31 +155,23 @@ describe('SignalCli', () => {
             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');
+                .mockResolvedValue({});
+            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');
+            await signalCli.finishChangeNumber('+1987654321', '123456', 'pin-code');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('finishChangeNumber', {
                 account: '+1234567890',
-                code: '123456',
+                number: '+1987654321',
+                verificationCode: '123456',
                 pin: 'pin-code'
             });
         });
@@ -415,6 +407,51 @@ describe('SignalCli', () => {
             expect(result).toEqual(mockResponse.accounts);
         });
     });
+    // Test device management (v0.13.23+)
+    describe('Device Management', () => {
+        beforeEach(() => {
+            jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
+        });
+        it('should list devices', async () => {
+            const mockDevices = [
+                { id: 1, name: 'Device 1' },
+                { id: 2, name: 'Device 2' }
+            ];
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(mockDevices);
+            const result = await signalCli.listDevices();
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listDevices', {
+                account: '+1234567890'
+            });
+            expect(result).toEqual(mockDevices);
+        });
+        it('should update device name', async () => {
+            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+                .mockResolvedValue(undefined);
+            await signalCli.updateDevice({
+                deviceId: 2,
+                deviceName: 'My Updated Device'
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateDevice', {
+                account: '+1234567890',
+                deviceId: 2,
+                deviceName: 'My Updated Device'
+            });
+        });
+        it('should validate device ID when updating', async () => {
+            await expect(signalCli.updateDevice({
+                deviceId: -1,
+                deviceName: 'Invalid'
+            })).rejects.toThrow();
+        });
+        it('should validate device name length', async () => {
+            const longName = 'a'.repeat(201);
+            await expect(signalCli.updateDevice({
+                deviceId: 2,
+                deviceName: longName
+            })).rejects.toThrow();
+        });
+    });
     // Test v0.1.0 features: Synchronization
     describe('Synchronization', () => {
         beforeEach(() => {

package/dist/config.d.ts

@@ -31,8 +31,23 @@ export interface SignalCliConfig {
     trustNewIdentities?: 'on-first-use' | 'always' | 'never';
     /** Disable send log (for message resending) */
     disableSendLog?: boolean;
+    /** Daemon connection mode: json-rpc (default), unix-socket, tcp, http */
+    daemonMode?: 'json-rpc' | 'unix-socket' | 'tcp' | 'http';
+    /** Unix socket path (for unix-socket mode) */
+    socketPath?: string;
+    /** TCP host (for tcp mode) */
+    tcpHost?: string;
+    /** TCP port (for tcp or http mode) */
+    tcpPort?: number;
+    /** HTTP base URL (for http mode) */
+    httpBaseUrl?: string;
 }
-export declare const DEFAULT_CONFIG: Required<SignalCliConfig>;
+export declare const DEFAULT_CONFIG: Required<Omit<SignalCliConfig, 'socketPath' | 'tcpHost' | 'tcpPort' | 'httpBaseUrl'> & {
+    socketPath: string;
+    tcpHost: string;
+    tcpPort: number;
+    httpBaseUrl: string;
+}>;
 /**
  * Validates and merges configuration with defaults
  * @param userConfig User-provided configuration

package/dist/config.js

@@ -20,7 +20,12 @@ exports.DEFAULT_CONFIG = {
     minRequestInterval: 100,
     autoReconnect: true,
     trustNewIdentities: 'on-first-use',
-    disableSendLog: false
+    disableSendLog: false,
+    daemonMode: 'json-rpc',
+    socketPath: '/tmp/signal-cli.sock',
+    tcpHost: 'localhost',
+    tcpPort: 7583,
+    httpBaseUrl: 'http://localhost:8080'
 };
 /**
  * Validates and merges configuration with defaults

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { SignalCli } from './SignalCli';
 export { SignalBot } from './SignalBot';
+export { MultiAccountManager } from './MultiAccountManager';
 export * from './interfaces';
 export * from './errors';
 export * from './validators';

package/dist/index.js

@@ -14,11 +14,13 @@ 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;
+exports.MultiAccountManager = 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; } });
+var MultiAccountManager_1 = require("./MultiAccountManager");
+Object.defineProperty(exports, "MultiAccountManager", { enumerable: true, get: function () { return MultiAccountManager_1.MultiAccountManager; } });
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./validators"), exports);

package/dist/interfaces.d.ts

@@ -278,6 +278,8 @@ export interface SendResponse {
 export interface GroupInfo {
     /** Base64 encoded group ID */
     groupId: string;
+    /** Alias for groupId */
+    id?: string;
     /** Group display name */
     name: string;
     /** Group description */
@@ -306,17 +308,23 @@ export interface GroupInfo {
     permissionSendMessage: string;
     /** Group invite link */
     groupInviteLink?: string;
+    /** Alias for groupInviteLink */
+    inviteLink?: string;
 }
 /**
  * Represents a received message.
  */
 export interface Message {
-    id: string;
+    id?: string;
     source: string;
+    sourceUuid?: string;
+    sourceDevice?: number;
     text?: string;
     timestamp: number;
     attachments?: Attachment[];
     reactions?: Reaction[];
+    reaction?: any;
+    groupId?: string;
     groupInfo?: {
         id: string;
         name?: string;
@@ -333,8 +341,12 @@ export interface Message {
     textStyles?: TextStyle[];
     expiresInSeconds?: number;
     isViewOnce?: boolean;
+    viewOnce?: boolean;
     remoteDelete?: boolean;
     isExpirationUpdate?: boolean;
+    syncMessage?: any;
+    receipt?: any;
+    typing?: any;
 }
 /**
  * Represents a mention in a message.
@@ -343,6 +355,7 @@ export interface Mention {
     start: number;
     length: number;
     number: string;
+    recipient?: string;
     name?: string;
 }
 /**
@@ -379,11 +392,23 @@ export interface Contact {
     uuid?: string;
     blocked: boolean;
     profileName?: string;
+    /** Given name (first name) from profile */
+    givenName?: string;
+    /** Family name (last name) from profile */
+    familyName?: string;
+    /** MobileCoin address for payments */
+    mobileCoinAddress?: string;
     profileAvatar?: string;
     color?: string;
     archived?: boolean;
     mutedUntil?: number;
     hideStory?: boolean;
+    /** Profile key for encrypted profile access */
+    profileKey?: string;
+    /** Contact's username */
+    username?: string;
+    /** Whether this contact is a registered Signal user */
+    registered?: boolean;
 }
 /**
  * Represents a Signal group.
@@ -393,6 +418,14 @@ export interface Group {
     name: string;
     members: string[];
     admins?: string[];
+    /** Pending members awaiting invite acceptance */
+    pendingMembers?: string[];
+    /** Banned members who cannot rejoin */
+    bannedMembers?: string[];
+    /** Group invite link for joining */
+    inviteLink?: string;
+    /** Whether invite link approval is required */
+    inviteLinkRequiresApproval?: boolean;
     isBlocked: boolean;
     isMember: boolean;
     isAdmin?: boolean;
@@ -401,12 +434,15 @@ export interface Group {
     color?: string;
     archived?: boolean;
     mutedUntil?: number;
-    inviteLink?: string;
     permissionAddMember?: 'EVERY_MEMBER' | 'ONLY_ADMINS';
     permissionEditDetails?: 'EVERY_MEMBER' | 'ONLY_ADMINS';
     permissionSendMessage?: 'EVERY_MEMBER' | 'ONLY_ADMINS';
     announcementsOnly?: boolean;
     expirationTimer?: number;
+    /** Group version (v1 or v2) */
+    version?: number;
+    /** Group master key for v2 groups */
+    masterKey?: string;
 }
 /**
  * Options for updating a Signal group.
@@ -469,15 +505,18 @@ export interface SendMessageOptions {
         text?: string;
         attachments?: Attachment[];
         mentions?: Mention[];
+        textStyles?: TextStyle[];
     };
     sticker?: Sticker;
     expiresInSeconds?: number;
     isViewOnce?: boolean;
     linkPreview?: boolean;
-    editMessage?: {
-        timestamp: number;
-        dataMessage: any;
-    };
+    previewUrl?: string;
+    editTimestamp?: number;
+    storyTimestamp?: number;
+    storyAuthor?: string;
+    noteToSelf?: boolean;
+    endSession?: boolean;
 }
 /**
  * Represents a user profile.
@@ -583,9 +622,10 @@ export interface PinConfiguration {
 export interface IdentityKey {
     number: string;
     identityKey: string;
-    trustLevel: 'TRUSTED_UNVERIFIED' | 'TRUSTED_VERIFIED' | 'UNTRUSTED';
-    addedDate: number;
-    firstUse: boolean;
+    safetyNumber?: string;
+    trustLevel?: 'TRUSTED_UNVERIFIED' | 'TRUSTED_VERIFIED' | 'UNTRUSTED' | 'TRUST_ON_FIRST_USE';
+    addedDate?: number;
+    firstUse?: boolean;
 }
 /**
  * Represents a user status (registered/unregistered).
@@ -1055,6 +1095,30 @@ export interface AccountUpdateResult {
     /** Error message if failed */
     error?: string;
 }
+/**
+ * Options for updating a linked device
+ */
+export interface UpdateDeviceOptions {
+    /** Device ID to update */
+    deviceId: number;
+    /** New device name */
+    deviceName: string;
+}
+/**
+ * Options for receiving messages
+ */
+export interface ReceiveOptions {
+    /** Timeout in seconds (default: 5) */
+    timeout?: number;
+    /** Maximum number of messages to receive (default: unlimited) */
+    maxMessages?: number;
+    /** Skip downloading attachments */
+    ignoreAttachments?: boolean;
+    /** Skip receiving stories */
+    ignoreStories?: boolean;
+    /** Send read receipts automatically */
+    sendReadReceipts?: boolean;
+}
 /**
  * Options for sending contacts sync
  */

package/dist/retry.js

@@ -70,14 +70,31 @@ async function withRetry(operation, options = {}) {
  * @returns Result of the promise
  */
 async function withTimeout(promise, timeoutMs) {
-    return Promise.race([
-        promise,
-        new Promise((_, reject) => {
-            setTimeout(() => {
-                reject(new errors_1.TimeoutError(`Operation timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
-        })
-    ]);
+    let timeoutHandle = null;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+            reject(new errors_1.TimeoutError(`Operation timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        // Use unref() to prevent this timer from keeping the process alive
+        if (timeoutHandle.unref) {
+            timeoutHandle.unref();
+        }
+    });
+    try {
+        const result = await Promise.race([promise, timeoutPromise]);
+        // Clear the timeout if the promise resolves first
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+        return result;
+    }
+    catch (error) {
+        // Clear the timeout if the promise rejects
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+        throw error;
+    }
 }
 /**
  * Sleep for a specified duration

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signal-sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A comprehensive TypeScript SDK for Signal Messenger with native JSON-RPC support, providing high-performance messaging, bot framework, and full signal-cli integration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/scripts/install.js

@@ -3,7 +3,7 @@ const fs = require('fs');
 const path = require('path');
 const tar = require('tar');
 
-const VERSION = '0.13.22';
+const VERSION = '0.13.23';
 const BASE_URL = `https://github.com/AsamK/signal-cli/releases/download/v${VERSION}`;
 
 const platform = process.platform;