signal-sdk 0.0.9 → 0.1.1

package/dist/__tests__/validators.test.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Basic tests for validators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const validators_1 = require("../validators");
+const errors_1 = require("../errors");
+describe('Validators', () => {
+    describe('validatePhoneNumber', () => {
+        it('should accept valid E.164 phone numbers', () => {
+            expect(() => (0, validators_1.validatePhoneNumber)('+33123456789')).not.toThrow();
+            expect(() => (0, validators_1.validatePhoneNumber)('+1234567890')).not.toThrow();
+            expect(() => (0, validators_1.validatePhoneNumber)('+49123456789012')).not.toThrow();
+        });
+        it('should reject invalid phone numbers', () => {
+            expect(() => (0, validators_1.validatePhoneNumber)('123456789')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validatePhoneNumber)('+0123456789')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validatePhoneNumber)('invalid')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validatePhoneNumber)('')).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string inputs', () => {
+            expect(() => (0, validators_1.validatePhoneNumber)(null)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validatePhoneNumber)(undefined)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validatePhoneNumber)(123)).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateGroupId', () => {
+        it('should accept non-empty strings', () => {
+            expect(() => (0, validators_1.validateGroupId)('abc123==')).not.toThrow();
+            expect(() => (0, validators_1.validateGroupId)('groupId')).not.toThrow();
+        });
+        it('should reject empty or invalid group IDs', () => {
+            expect(() => (0, validators_1.validateGroupId)('')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateGroupId)(null)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateGroupId)(undefined)).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string group IDs', () => {
+            expect(() => (0, validators_1.validateGroupId)(123)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateGroupId)({})).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateRecipient', () => {
+        it('should accept valid phone numbers', () => {
+            expect(() => (0, validators_1.validateRecipient)('+33123456789')).not.toThrow();
+        });
+        it('should accept usernames', () => {
+            expect(() => (0, validators_1.validateRecipient)('u:username.001')).not.toThrow();
+        });
+        it('should accept UUIDs', () => {
+            expect(() => (0, validators_1.validateRecipient)('12345678-1234-1234-1234-123456789012')).not.toThrow();
+            expect(() => (0, validators_1.validateRecipient)('PNI:12345678-1234-1234-1234-123456789012')).not.toThrow();
+        });
+        it('should reject invalid recipients', () => {
+            expect(() => (0, validators_1.validateRecipient)('')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateRecipient)('u:')).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string recipients', () => {
+            expect(() => (0, validators_1.validateRecipient)(null)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateRecipient)(123)).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateMessage', () => {
+        it('should accept valid messages', () => {
+            expect(() => (0, validators_1.validateMessage)('Hello')).not.toThrow();
+            expect(() => (0, validators_1.validateMessage)('', 10)).not.toThrow();
+        });
+        it('should reject messages exceeding max length', () => {
+            expect(() => (0, validators_1.validateMessage)('Hello World', 5)).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string messages', () => {
+            expect(() => (0, validators_1.validateMessage)(null)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateMessage)(undefined)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateMessage)(123)).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateAttachments', () => {
+        it('should accept valid attachment arrays', () => {
+            expect(() => (0, validators_1.validateAttachments)(['file1.txt', 'file2.jpg'])).not.toThrow();
+            expect(() => (0, validators_1.validateAttachments)([])).not.toThrow();
+        });
+        it('should reject non-array inputs', () => {
+            expect(() => (0, validators_1.validateAttachments)('not-an-array')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateAttachments)(null)).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string attachment paths', () => {
+            expect(() => (0, validators_1.validateAttachments)([123])).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateAttachments)([null])).toThrow(errors_1.ValidationError);
+        });
+        it('should reject empty attachment paths', () => {
+            expect(() => (0, validators_1.validateAttachments)([''])).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateAttachments)(['file1.txt', ''])).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateTimestamp', () => {
+        it('should accept valid timestamps', () => {
+            expect(() => (0, validators_1.validateTimestamp)(Date.now())).not.toThrow();
+            expect(() => (0, validators_1.validateTimestamp)(1234567890)).not.toThrow();
+        });
+        it('should reject invalid timestamps', () => {
+            expect(() => (0, validators_1.validateTimestamp)(0)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateTimestamp)(-1)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateTimestamp)(Infinity)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateTimestamp)('123')).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateEmoji', () => {
+        it('should accept valid emojis', () => {
+            expect(() => (0, validators_1.validateEmoji)('👍')).not.toThrow();
+            expect(() => (0, validators_1.validateEmoji)('❤️')).not.toThrow();
+            expect(() => (0, validators_1.validateEmoji)('😀')).not.toThrow();
+        });
+        it('should reject invalid emojis', () => {
+            expect(() => (0, validators_1.validateEmoji)('')).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateEmoji)('this is too long')).toThrow(errors_1.ValidationError);
+        });
+        it('should reject non-string emojis', () => {
+            expect(() => (0, validators_1.validateEmoji)(null)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateEmoji)(123)).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('validateDeviceId', () => {
+        it('should accept valid device IDs', () => {
+            expect(() => (0, validators_1.validateDeviceId)(1)).not.toThrow();
+            expect(() => (0, validators_1.validateDeviceId)(123)).not.toThrow();
+        });
+        it('should reject invalid device IDs', () => {
+            expect(() => (0, validators_1.validateDeviceId)(0)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateDeviceId)(-1)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateDeviceId)(1.5)).toThrow(errors_1.ValidationError);
+            expect(() => (0, validators_1.validateDeviceId)('1')).toThrow(errors_1.ValidationError);
+        });
+    });
+    describe('sanitizeInput', () => {
+        it('should remove null bytes', () => {
+            expect((0, validators_1.sanitizeInput)('hello\0world')).toBe('helloworld');
+            expect((0, validators_1.sanitizeInput)('test\0\0test')).toBe('testtest');
+        });
+        it('should handle non-string inputs', () => {
+            expect((0, validators_1.sanitizeInput)(null)).toBe('');
+            expect((0, validators_1.sanitizeInput)(undefined)).toBe('');
+            expect((0, validators_1.sanitizeInput)(123)).toBe('');
+        });
+        it('should preserve normal strings', () => {
+            expect((0, validators_1.sanitizeInput)('hello world')).toBe('hello world');
+        });
+    });
+});

package/dist/config.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Configuration management for Signal SDK
+ * Provides centralized configuration with validation
+ */
+export interface SignalCliConfig {
+    /** Path to signal-cli binary */
+    signalCliPath?: string;
+    /** Signal account phone number */
+    account?: string;
+    /** Connection timeout in milliseconds */
+    connectionTimeout?: number;
+    /** Request timeout in milliseconds */
+    requestTimeout?: number;
+    /** Enable retry on failures */
+    enableRetry?: boolean;
+    /** Maximum retry attempts */
+    maxRetries?: number;
+    /** Initial retry delay in milliseconds */
+    retryDelay?: number;
+    /** Enable detailed logging */
+    verbose?: boolean;
+    /** Log file path */
+    logFile?: string;
+    /** Rate limit: max concurrent requests */
+    maxConcurrentRequests?: number;
+    /** Rate limit: minimum interval between requests (ms) */
+    minRequestInterval?: number;
+    /** Auto-reconnect on connection loss */
+    autoReconnect?: boolean;
+    /** Trust new identities mode */
+    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<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
+ * @returns Validated configuration
+ */
+export declare function validateConfig(userConfig?: SignalCliConfig): Required<SignalCliConfig>;
+/**
+ * Logger configuration and utilities
+ */
+export interface LoggerConfig {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    enableConsole: boolean;
+    enableFile: boolean;
+    filePath?: string;
+    includeTimestamp: boolean;
+    includeLevel: boolean;
+}
+export declare const DEFAULT_LOGGER_CONFIG: LoggerConfig;
+/**
+ * Simple logger implementation
+ */
+export declare class Logger {
+    private config;
+    private levels;
+    constructor(config?: Partial<LoggerConfig>);
+    private shouldLog;
+    private format;
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, data?: any): void;
+}

package/dist/config.js

@@ -0,0 +1,116 @@
+"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,
+    daemonMode: 'json-rpc',
+    socketPath: '/tmp/signal-cli.sock',
+    tcpHost: 'localhost',
+    tcpPort: 7583,
+    httpBaseUrl: 'http://localhost:8080'
+};
+/**
+ * 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,8 @@
 export { SignalCli } from './SignalCli';
 export { SignalBot } from './SignalBot';
+export { MultiAccountManager } from './MultiAccountManager';
 export * from './interfaces';
+export * from './errors';
+export * from './validators';
+export * from './retry';
+export * from './config';

package/dist/index.js

@@ -14,9 +14,15 @@ 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);
+__exportStar(require("./retry"), exports);
+__exportStar(require("./config"), exports);