signal-sdk 0.0.9 → 0.1.1

package/dist/interfaces.d.ts

@@ -5,7 +5,7 @@
  * which uses JSON-RPC communication with signal-cli for optimal performance.
  *
  * @author Signal SDK Team
- * @version 2.0.0
+ * @version 0.1.0
  */
 /**
  * @deprecated This interface is no longer used since switching to JSON-RPC format.
@@ -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).
@@ -936,3 +976,153 @@ export interface UploadProgress {
     /** Estimated time remaining in seconds */
     timeRemaining?: number;
 }
+/**
+ * Options for creating a poll
+ */
+export interface PollCreateOptions {
+    /** The poll question */
+    question: string;
+    /** Array of poll options */
+    options: string[];
+    /** Allow multiple selections (default: true) */
+    multiSelect?: boolean;
+    /** Recipients to send the poll to */
+    recipients?: string[];
+    /** Group ID to send the poll to */
+    groupId?: string;
+}
+/**
+ * Options for voting on a poll
+ */
+export interface PollVoteOptions {
+    /** Author of the poll */
+    pollAuthor: string;
+    /** Timestamp of the poll message */
+    pollTimestamp: number;
+    /** Array of option indexes to vote for */
+    optionIndexes: number[];
+    /** Vote count (increase for each vote) */
+    voteCount?: number;
+}
+/**
+ * Options for terminating a poll
+ */
+export interface PollTerminateOptions {
+    /** Timestamp of the poll message to terminate */
+    pollTimestamp: number;
+}
+/**
+ * Options for sending a story
+ */
+export interface StoryOptions {
+    /** Story content (text or attachment path) */
+    content?: string;
+    /** Attachment for the story */
+    attachment?: string;
+    /** Text attachment with style */
+    textAttachment?: {
+        text: string;
+        textStyle?: 'DEFAULT' | 'REGULAR' | 'BOLD' | 'SERIF' | 'SCRIPT' | 'CONDENSED';
+        textForegroundColor?: string;
+        textBackgroundColor?: string;
+        preview?: {
+            url: string;
+            title?: string;
+            description?: string;
+        };
+    };
+    /** Allow replies (default: true) */
+    allowReplies?: boolean;
+}
+/**
+ * Options for getting attachment data
+ */
+export interface GetAttachmentOptions {
+    /** Attachment ID */
+    id: string;
+    /** Recipient who sent the attachment */
+    recipient?: string;
+    /** Group ID where attachment was sent */
+    groupId?: string;
+}
+/**
+ * Options for getting avatar data
+ */
+export interface GetAvatarOptions {
+    /** Contact number for contact avatar */
+    contact?: string;
+    /** Profile number for profile avatar */
+    profile?: string;
+    /** Group ID for group avatar */
+    groupId?: string;
+}
+/**
+ * Options for getting sticker data
+ */
+export interface GetStickerOptions {
+    /** Sticker pack ID (hex encoded) */
+    packId: string;
+    /** Sticker index in the pack */
+    stickerId: number;
+}
+/**
+ * Options for updating account information
+ */
+export interface UpdateAccountOptions {
+    /** New device name */
+    deviceName?: string;
+    /** Username to set (with or without discriminator) */
+    username?: string;
+    /** Delete the current username */
+    deleteUsername?: boolean;
+    /** Enable unrestricted unidentified sender */
+    unrestrictedUnidentifiedSender?: boolean;
+    /** Enable discoverability by phone number */
+    discoverableByNumber?: boolean;
+    /** Enable number sharing */
+    numberSharing?: boolean;
+}
+/**
+ * Result from account update with username
+ */
+export interface AccountUpdateResult {
+    /** Success status */
+    success: boolean;
+    /** New username with discriminator */
+    username?: string;
+    /** Username link URL */
+    usernameLink?: string;
+    /** Error message if failed */
+    error?: 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
+ */
+export interface SendContactsOptions {
+    /** Include all recipients, not just contacts */
+    includeAllRecipients?: boolean;
+}
+/**
+ * Options for listing groups
+ */
+export interface ListGroupsOptions {
+    /** Show detailed information */
+    detailed?: boolean;
+    /** Filter by specific group IDs */
+    groupIds?: string[];
+}

package/dist/interfaces.js

@@ -6,6 +6,6 @@
  * which uses JSON-RPC communication with signal-cli for optimal performance.
  *
  * @author Signal SDK Team
- * @version 2.0.0
+ * @version 0.1.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/retry.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Retry utilities with exponential backoff
+ * Provides robust retry mechanisms for operations
+ */
+export interface RetryOptions {
+    /** Maximum number of retry attempts */
+    maxAttempts?: number;
+    /** Initial delay in milliseconds */
+    initialDelay?: number;
+    /** Maximum delay in milliseconds */
+    maxDelay?: number;
+    /** Multiplier for exponential backoff */
+    backoffMultiplier?: number;
+    /** Timeout for each attempt in milliseconds */
+    timeout?: number;
+    /** Function to determine if error is retryable */
+    isRetryable?: (error: any) => boolean;
+    /** Callback for each retry attempt */
+    onRetry?: (attempt: number, error: any) => void;
+}
+/**
+ * Executes an operation with retry logic and exponential backoff
+ * @param operation Function to execute
+ * @param options Retry configuration options
+ * @returns Result of the operation
+ */
+export declare function withRetry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Executes an operation with a timeout
+ * @param promise Promise to execute
+ * @param timeoutMs Timeout in milliseconds
+ * @returns Result of the promise
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T>;
+/**
+ * Sleep for a specified duration
+ * @param ms Duration in milliseconds
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Rate limiter to prevent exceeding API limits
+ */
+export declare class RateLimiter {
+    private maxConcurrent;
+    private minInterval;
+    private queue;
+    private activeRequests;
+    constructor(maxConcurrent?: number, minInterval?: number);
+    /**
+     * Execute an operation with rate limiting
+     * @param operation Function to execute
+     * @returns Result of the operation
+     */
+    execute<T>(operation: () => Promise<T>): Promise<T>;
+    private reserveSlot;
+}

package/dist/retry.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Retry utilities with exponential backoff
+ * Provides robust retry mechanisms for operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiter = void 0;
+exports.withRetry = withRetry;
+exports.withTimeout = withTimeout;
+exports.sleep = sleep;
+const errors_1 = require("./errors");
+const DEFAULT_RETRY_OPTIONS = {
+    maxAttempts: 3,
+    initialDelay: 1000,
+    maxDelay: 30000,
+    backoffMultiplier: 2,
+    timeout: 60000,
+    isRetryable: (error) => {
+        // Retry on connection errors, timeouts, and certain server errors
+        if (!error)
+            return false;
+        const errorMessage = error.message?.toLowerCase() || '';
+        const isConnectionError = errorMessage.includes('connection') ||
+            errorMessage.includes('timeout') ||
+            errorMessage.includes('econnrefused') ||
+            errorMessage.includes('econnreset');
+        const isServerError = error.code === 500 || error.code === 502 || error.code === 503;
+        // Don't retry on authentication or validation errors
+        const isClientError = error.code === 401 || error.code === 403 || error.code === 400;
+        return (isConnectionError || isServerError) && !isClientError;
+    },
+    onRetry: () => { }
+};
+/**
+ * Executes an operation with retry logic and exponential backoff
+ * @param operation Function to execute
+ * @param options Retry configuration options
+ * @returns Result of the operation
+ */
+async function withRetry(operation, options = {}) {
+    const config = { ...DEFAULT_RETRY_OPTIONS, ...options };
+    let lastError;
+    for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+        try {
+            // Execute with timeout
+            const result = await withTimeout(operation(), config.timeout);
+            return result;
+        }
+        catch (error) {
+            lastError = error;
+            // Check if we should retry
+            const shouldRetry = attempt < config.maxAttempts && config.isRetryable(error);
+            if (!shouldRetry) {
+                throw error;
+            }
+            // Calculate delay with exponential backoff
+            const delay = Math.min(config.initialDelay * Math.pow(config.backoffMultiplier, attempt - 1), config.maxDelay);
+            // Notify about retry
+            config.onRetry(attempt, error);
+            // Wait before retrying
+            await sleep(delay);
+        }
+    }
+    throw lastError;
+}
+/**
+ * Executes an operation with a timeout
+ * @param promise Promise to execute
+ * @param timeoutMs Timeout in milliseconds
+ * @returns Result of the promise
+ */
+async function withTimeout(promise, 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
+ * @param ms Duration in milliseconds
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Rate limiter to prevent exceeding API limits
+ */
+class RateLimiter {
+    constructor(maxConcurrent = 5, minInterval = 100) {
+        this.maxConcurrent = maxConcurrent;
+        this.minInterval = minInterval;
+        this.queue = [];
+        this.activeRequests = 0;
+    }
+    /**
+     * Execute an operation with rate limiting
+     * @param operation Function to execute
+     * @returns Result of the operation
+     */
+    async execute(operation) {
+        // Wait for slot and reserve it
+        await this.reserveSlot();
+        try {
+            const result = await operation();
+            return result;
+        }
+        finally {
+            // Wait minimum interval before allowing next request
+            await sleep(this.minInterval);
+            // Release slot
+            this.activeRequests--;
+            const next = this.queue.shift();
+            if (next) {
+                next();
+            }
+        }
+    }
+    reserveSlot() {
+        if (this.activeRequests < this.maxConcurrent) {
+            this.activeRequests++;
+            return Promise.resolve();
+        }
+        return new Promise(resolve => {
+            this.queue.push(() => {
+                this.activeRequests++;
+                resolve();
+            });
+        });
+    }
+}
+exports.RateLimiter = RateLimiter;

package/dist/validators.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Input validation utilities for Signal SDK
+ * Provides strict validation for all inputs
+ */
+/**
+ * Validates a phone number format (E.164)
+ * @param phoneNumber Phone number to validate
+ * @throws ValidationError if invalid
+ */
+export declare function validatePhoneNumber(phoneNumber: string): void;
+/**
+ * Validates a group ID format
+ * @param groupId Group ID to validate
+ * @throws ValidationError if invalid
+ */
+export declare function validateGroupId(groupId: string): void;
+/**
+ * Validates a recipient (phone number, UUID, or username)
+ * @param recipient Recipient to validate
+ * @throws ValidationError if invalid
+ */
+export declare function validateRecipient(recipient: string): void;
+/**
+ * Validates a message text
+ * @param message Message to validate
+ * @param maxLength Maximum message length
+ * @throws ValidationError if invalid
+ */
+export declare function validateMessage(message: string, maxLength?: number): void;
+/**
+ * Validates file attachments
+ * @param attachments Array of attachment paths
+ * @throws ValidationError if invalid
+ */
+export declare function validateAttachments(attachments: string[]): void;
+/**
+ * Validates a timestamp
+ * @param timestamp Timestamp to validate
+ * @throws ValidationError if invalid
+ */
+export declare function validateTimestamp(timestamp: number): void;
+/**
+ * Validates an emoji string
+ * @param emoji Emoji to validate
+ * @throws ValidationError if invalid
+ */
+export declare function validateEmoji(emoji: string): void;
+/**
+ * Validates device ID
+ * @param deviceId Device ID to validate
+ * @throws ValidationError if invalid
+ */
+export declare function validateDeviceId(deviceId: number): void;
+/**
+ * Sanitizes user input to prevent injection attacks
+ * @param input Input string to sanitize
+ * @returns Sanitized string
+ */
+export declare function sanitizeInput(input: string): string;