signal-sdk 0.0.8 → 0.1.0

package/dist/interfaces.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Signal CLI SDK TypeScript Interfaces
+ *
+ * This file contains comprehensive type definitions for the Signal CLI SDK,
+ * which uses JSON-RPC communication with signal-cli for optimal performance.
+ *
+ * @author Signal SDK Team
+ * @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;

package/dist/validators.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Input validation utilities for Signal SDK
+ * Provides strict validation for all inputs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePhoneNumber = validatePhoneNumber;
+exports.validateGroupId = validateGroupId;
+exports.validateRecipient = validateRecipient;
+exports.validateMessage = validateMessage;
+exports.validateAttachments = validateAttachments;
+exports.validateTimestamp = validateTimestamp;
+exports.validateEmoji = validateEmoji;
+exports.validateDeviceId = validateDeviceId;
+exports.sanitizeInput = sanitizeInput;
+const errors_1 = require("./errors");
+/**
+ * Validates a phone number format (E.164)
+ * @param phoneNumber Phone number to validate
+ * @throws ValidationError if invalid
+ */
+function validatePhoneNumber(phoneNumber) {
+    if (!phoneNumber) {
+        throw new errors_1.ValidationError('Phone number is required', 'phoneNumber');
+    }
+    if (typeof phoneNumber !== 'string') {
+        throw new errors_1.ValidationError('Phone number must be a string', 'phoneNumber');
+    }
+    // E.164 format: + followed by 1-15 digits
+    const e164Regex = /^\+[1-9]\d{1,14}$/;
+    if (!e164Regex.test(phoneNumber)) {
+        throw new errors_1.ValidationError('Phone number must be in E.164 format (e.g., +33123456789)', 'phoneNumber');
+    }
+}
+/**
+ * Validates a group ID format
+ * @param groupId Group ID to validate
+ * @throws ValidationError if invalid
+ */
+function validateGroupId(groupId) {
+    if (!groupId) {
+        throw new errors_1.ValidationError('Group ID is required', 'groupId');
+    }
+    if (typeof groupId !== 'string') {
+        throw new errors_1.ValidationError('Group ID must be a string', 'groupId');
+    }
+}
+/**
+ * Validates a recipient (phone number, UUID, or username)
+ * @param recipient Recipient to validate
+ * @throws ValidationError if invalid
+ */
+function validateRecipient(recipient) {
+    if (!recipient) {
+        throw new errors_1.ValidationError('Recipient is required', 'recipient');
+    }
+    if (typeof recipient !== 'string') {
+        throw new errors_1.ValidationError('Recipient must be a string', 'recipient');
+    }
+    // Check if it's a username (starts with u:)
+    if (recipient.startsWith('u:')) {
+        if (recipient.length < 3) {
+            throw new errors_1.ValidationError('Username is too short', 'recipient');
+        }
+        return;
+    }
+    // Check if it's a UUID (PNI: prefix or plain UUID)
+    const uuidRegex = /^(PNI:)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (uuidRegex.test(recipient)) {
+        return;
+    }
+    // Otherwise, validate as phone number
+    validatePhoneNumber(recipient);
+}
+/**
+ * Validates a message text
+ * @param message Message to validate
+ * @param maxLength Maximum message length
+ * @throws ValidationError if invalid
+ */
+function validateMessage(message, maxLength = 10000) {
+    if (message === undefined || message === null) {
+        throw new errors_1.ValidationError('Message is required', 'message');
+    }
+    if (typeof message !== 'string') {
+        throw new errors_1.ValidationError('Message must be a string', 'message');
+    }
+    if (message.length > maxLength) {
+        throw new errors_1.ValidationError(`Message exceeds maximum length of ${maxLength} characters`, 'message');
+    }
+}
+/**
+ * Validates file attachments
+ * @param attachments Array of attachment paths
+ * @throws ValidationError if invalid
+ */
+function validateAttachments(attachments) {
+    if (!Array.isArray(attachments)) {
+        throw new errors_1.ValidationError('Attachments must be an array', 'attachments');
+    }
+    for (const attachment of attachments) {
+        if (typeof attachment !== 'string') {
+            throw new errors_1.ValidationError('Each attachment must be a file path string', 'attachments');
+        }
+        if (attachment.length === 0) {
+            throw new errors_1.ValidationError('Attachment path cannot be empty', 'attachments');
+        }
+    }
+}
+/**
+ * Validates a timestamp
+ * @param timestamp Timestamp to validate
+ * @throws ValidationError if invalid
+ */
+function validateTimestamp(timestamp) {
+    if (typeof timestamp !== 'number') {
+        throw new errors_1.ValidationError('Timestamp must be a number', 'timestamp');
+    }
+    if (timestamp <= 0) {
+        throw new errors_1.ValidationError('Timestamp must be positive', 'timestamp');
+    }
+    if (!Number.isFinite(timestamp)) {
+        throw new errors_1.ValidationError('Timestamp must be finite', 'timestamp');
+    }
+}
+/**
+ * Validates an emoji string
+ * @param emoji Emoji to validate
+ * @throws ValidationError if invalid
+ */
+function validateEmoji(emoji) {
+    if (!emoji) {
+        throw new errors_1.ValidationError('Emoji is required', 'emoji');
+    }
+    if (typeof emoji !== 'string') {
+        throw new errors_1.ValidationError('Emoji must be a string', 'emoji');
+    }
+    // Basic emoji validation - should be a single grapheme cluster
+    if (emoji.length === 0 || emoji.length > 10) {
+        throw new errors_1.ValidationError('Invalid emoji format', 'emoji');
+    }
+}
+/**
+ * Validates device ID
+ * @param deviceId Device ID to validate
+ * @throws ValidationError if invalid
+ */
+function validateDeviceId(deviceId) {
+    if (typeof deviceId !== 'number') {
+        throw new errors_1.ValidationError('Device ID must be a number', 'deviceId');
+    }
+    if (!Number.isInteger(deviceId)) {
+        throw new errors_1.ValidationError('Device ID must be an integer', 'deviceId');
+    }
+    if (deviceId <= 0) {
+        throw new errors_1.ValidationError('Device ID must be positive', 'deviceId');
+    }
+}
+/**
+ * Sanitizes user input to prevent injection attacks
+ * @param input Input string to sanitize
+ * @returns Sanitized string
+ */
+function sanitizeInput(input) {
+    if (typeof input !== 'string') {
+        return '';
+    }
+    // Remove null bytes
+    return input.replace(/\0/g, '');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signal-sdk",
-  "version": "0.0.8",
+  "version": "0.1.0",
   "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",
@@ -15,6 +15,7 @@
   ],
   "scripts": {
     "build": "tsc",
+    "prepublishOnly": "npm run build",
     "test": "jest",
     "postinstall": "node scripts/install.js",
     "connect": "node scripts/connect.js",
@@ -25,7 +26,8 @@
     "example:contact-management": "node examples/sdk/04-contact-management.js",
     "example:file-handling": "node examples/sdk/05-file-handling.js",
     "example:minimal-bot": "node examples/bot/01-minimal-bot.js",
-    "example:advanced-bot": "node examples/bot/02-advanced-bot.js"
+    "example:advanced-bot": "node examples/bot/02-advanced-bot.js",
+    "example:advanced-bot-2": "node examples/bot/03-advanced-bot.js"
   },
   "keywords": [
     "signal",
@@ -53,6 +55,7 @@
   "devDependencies": {
     "@types/jest": "^30.0.0",
     "@types/node": "^24.0.10",
+    "dotenv": "^16.4.5",
     "@types/qrcode-terminal": "^0.12.2",
     "@types/uuid": "^9.0.8",
     "jest": "^30.0.4",
@@ -61,10 +64,6 @@
   },
   "dependencies": {
     "axios": "^1.10.0",
-    "dotenv": "^16.4.5",
-    "duckduckgo-chat-interface": "^1.1.5",
-    "events": "^3.3.0",
-    "qrcode": "^1.5.3",
     "qrcode-terminal": "^0.12.0",
     "tar": "^7.4.3",
     "uuid": "^9.0.1"