signal-sdk 0.0.9 → 0.1.0

package/dist/config.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * Configuration management for Signal SDK
+ * Provides centralized configuration with validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.DEFAULT_LOGGER_CONFIG = exports.DEFAULT_CONFIG = void 0;
+exports.validateConfig = validateConfig;
+exports.DEFAULT_CONFIG = {
+    signalCliPath: '',
+    account: '',
+    connectionTimeout: 30000,
+    requestTimeout: 60000,
+    enableRetry: true,
+    maxRetries: 3,
+    retryDelay: 1000,
+    verbose: false,
+    logFile: '',
+    maxConcurrentRequests: 5,
+    minRequestInterval: 100,
+    autoReconnect: true,
+    trustNewIdentities: 'on-first-use',
+    disableSendLog: false
+};
+/**
+ * Validates and merges configuration with defaults
+ * @param userConfig User-provided configuration
+ * @returns Validated configuration
+ */
+function validateConfig(userConfig = {}) {
+    const config = { ...exports.DEFAULT_CONFIG, ...userConfig };
+    // Validate numeric values
+    if (config.connectionTimeout < 0) {
+        throw new Error('connectionTimeout must be non-negative');
+    }
+    if (config.requestTimeout < 0) {
+        throw new Error('requestTimeout must be non-negative');
+    }
+    if (config.maxRetries < 0) {
+        throw new Error('maxRetries must be non-negative');
+    }
+    if (config.retryDelay < 0) {
+        throw new Error('retryDelay must be non-negative');
+    }
+    if (config.maxConcurrentRequests < 1) {
+        throw new Error('maxConcurrentRequests must be at least 1');
+    }
+    if (config.minRequestInterval < 0) {
+        throw new Error('minRequestInterval must be non-negative');
+    }
+    return config;
+}
+exports.DEFAULT_LOGGER_CONFIG = {
+    level: 'info',
+    enableConsole: true,
+    enableFile: false,
+    includeTimestamp: true,
+    includeLevel: true
+};
+/**
+ * Simple logger implementation
+ */
+class Logger {
+    constructor(config = {}) {
+        this.levels = {
+            debug: 0,
+            info: 1,
+            warn: 2,
+            error: 3
+        };
+        this.config = { ...exports.DEFAULT_LOGGER_CONFIG, ...config };
+    }
+    shouldLog(level) {
+        return this.levels[level] >= this.levels[this.config.level];
+    }
+    format(level, message, data) {
+        const parts = [];
+        if (this.config.includeTimestamp) {
+            parts.push(`[${new Date().toISOString()}]`);
+        }
+        if (this.config.includeLevel) {
+            parts.push(`[${level.toUpperCase()}]`);
+        }
+        parts.push(message);
+        if (data !== undefined) {
+            parts.push(JSON.stringify(data, null, 2));
+        }
+        return parts.join(' ');
+    }
+    debug(message, data) {
+        if (this.shouldLog('debug') && this.config.enableConsole) {
+            console.debug(this.format('debug', message, data));
+        }
+    }
+    info(message, data) {
+        if (this.shouldLog('info') && this.config.enableConsole) {
+            console.info(this.format('info', message, data));
+        }
+    }
+    warn(message, data) {
+        if (this.shouldLog('warn') && this.config.enableConsole) {
+            console.warn(this.format('warn', message, data));
+        }
+    }
+    error(message, data) {
+        if (this.shouldLog('error') && this.config.enableConsole) {
+            console.error(this.format('error', message, data));
+        }
+    }
+}
+exports.Logger = Logger;

package/dist/errors.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Custom error classes for Signal SDK
+ * Provides typed errors for better error handling
+ */
+export declare class SignalError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export declare class ConnectionError extends SignalError {
+    constructor(message: string);
+}
+export declare class AuthenticationError extends SignalError {
+    constructor(message: string);
+}
+export declare class RateLimitError extends SignalError {
+    retryAfter?: number | undefined;
+    challenge?: string | undefined;
+    constructor(message: string, retryAfter?: number | undefined, challenge?: string | undefined);
+}
+export declare class ValidationError extends SignalError {
+    field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare class TimeoutError extends SignalError {
+    constructor(message?: string);
+}
+export declare class GroupError extends SignalError {
+    constructor(message: string);
+}
+export declare class MessageError extends SignalError {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Custom error classes for Signal SDK
+ * Provides typed errors for better error handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageError = exports.GroupError = exports.TimeoutError = exports.ValidationError = exports.RateLimitError = exports.AuthenticationError = exports.ConnectionError = exports.SignalError = void 0;
+class SignalError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'SignalError';
+        Object.setPrototypeOf(this, SignalError.prototype);
+    }
+}
+exports.SignalError = SignalError;
+class ConnectionError extends SignalError {
+    constructor(message) {
+        super(message, 'CONNECTION_ERROR');
+        this.name = 'ConnectionError';
+        Object.setPrototypeOf(this, ConnectionError.prototype);
+    }
+}
+exports.ConnectionError = ConnectionError;
+class AuthenticationError extends SignalError {
+    constructor(message) {
+        super(message, 'AUTH_ERROR');
+        this.name = 'AuthenticationError';
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class RateLimitError extends SignalError {
+    constructor(message, retryAfter, challenge) {
+        super(message, 'RATE_LIMIT');
+        this.retryAfter = retryAfter;
+        this.challenge = challenge;
+        this.name = 'RateLimitError';
+        Object.setPrototypeOf(this, RateLimitError.prototype);
+    }
+}
+exports.RateLimitError = RateLimitError;
+class ValidationError extends SignalError {
+    constructor(message, field) {
+        super(message, 'VALIDATION_ERROR');
+        this.field = field;
+        this.name = 'ValidationError';
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+exports.ValidationError = ValidationError;
+class TimeoutError extends SignalError {
+    constructor(message = 'Operation timed out') {
+        super(message, 'TIMEOUT');
+        this.name = 'TimeoutError';
+        Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+}
+exports.TimeoutError = TimeoutError;
+class GroupError extends SignalError {
+    constructor(message) {
+        super(message, 'GROUP_ERROR');
+        this.name = 'GroupError';
+        Object.setPrototypeOf(this, GroupError.prototype);
+    }
+}
+exports.GroupError = GroupError;
+class MessageError extends SignalError {
+    constructor(message) {
+        super(message, 'MESSAGE_ERROR');
+        this.name = 'MessageError';
+        Object.setPrototypeOf(this, MessageError.prototype);
+    }
+}
+exports.MessageError = MessageError;

package/dist/index.d.ts

@@ -1,3 +1,7 @@
 export { SignalCli } from './SignalCli';
 export { SignalBot } from './SignalBot';
 export * from './interfaces';
+export * from './errors';
+export * from './validators';
+export * from './retry';
+export * from './config';

package/dist/index.js

@@ -20,3 +20,7 @@ Object.defineProperty(exports, "SignalCli", { enumerable: true, get: function ()
 var SignalBot_1 = require("./SignalBot");
 Object.defineProperty(exports, "SignalBot", { enumerable: true, get: function () { return SignalBot_1.SignalBot; } });
 __exportStar(require("./interfaces"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./validators"), exports);
+__exportStar(require("./retry"), exports);
+__exportStar(require("./config"), exports);

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.
@@ -936,3 +936,138 @@ 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 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,135 @@
+"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) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new errors_1.TimeoutError(`Operation timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+        })
+    ]);
+}
+/**
+ * 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;