signal-sdk 0.0.9 → 0.1.1

package/dist/MultiAccountManager.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * Multi-Account Manager for Signal SDK
+ *
+ * Manages multiple Signal accounts simultaneously with event routing
+ * and isolated process management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiAccountManager = void 0;
+const SignalCli_1 = require("./SignalCli");
+const events_1 = require("events");
+const config_1 = require("./config");
+/**
+ * Multi-Account Manager
+ *
+ * Manages multiple Signal accounts with event routing and lifecycle management.
+ *
+ * @example
+ * ```typescript
+ * const manager = new MultiAccountManager({
+ *   dataPath: '/path/to/data',
+ *   autoReconnect: true
+ * });
+ *
+ * // Add accounts
+ * await manager.addAccount('+33123456789');
+ * await manager.addAccount('+33987654321');
+ *
+ * // Listen to events from all accounts
+ * manager.on('message', (account, message) => {
+ *   console.log(`Message from ${account}: ${message.text}`);
+ * });
+ *
+ * // Connect all accounts
+ * await manager.connectAll();
+ *
+ * // Send from specific account
+ * await manager.sendMessage('+33123456789', '+33111111111', 'Hello!');
+ * ```
+ */
+class MultiAccountManager extends events_1.EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.accounts = new Map();
+        this.options = options;
+        this.logger = new config_1.Logger({
+            level: options.verbose ? 'debug' : 'info',
+            enableFile: false
+        });
+        this.logger.info('MultiAccountManager initialized');
+    }
+    /**
+     * Add an account to the manager
+     *
+     * @param account - Phone number of the account
+     * @param config - Optional SignalCli configuration
+     * @returns The SignalCli instance
+     */
+    async addAccount(account, config = {}) {
+        if (this.accounts.has(account)) {
+            throw new Error(`Account ${account} already exists`);
+        }
+        this.logger.info(`Adding account: ${account}`);
+        // Create SignalCli instance with merged config
+        const signalConfig = {
+            signalCliPath: this.options.signalCliPath,
+            verbose: this.options.verbose,
+            ...config
+        };
+        const instance = new SignalCli_1.SignalCli(account, undefined, signalConfig);
+        // Forward events from this instance
+        this.setupEventForwarding(account, instance);
+        // Store the managed account
+        const managedAccount = {
+            account,
+            instance,
+            connected: false,
+            lastActivity: Date.now()
+        };
+        this.accounts.set(account, managedAccount);
+        this.emit('accountAdded', account);
+        this.logger.info(`Account ${account} added successfully`);
+        return instance;
+    }
+    /**
+     * Remove an account from the manager
+     *
+     * @param account - Phone number of the account
+     */
+    async removeAccount(account) {
+        const managedAccount = this.accounts.get(account);
+        if (!managedAccount) {
+            throw new Error(`Account ${account} not found`);
+        }
+        this.logger.info(`Removing account: ${account}`);
+        // Disconnect if connected
+        if (managedAccount.connected) {
+            await managedAccount.instance.disconnect();
+        }
+        // Remove all listeners
+        managedAccount.instance.removeAllListeners();
+        // Remove from map
+        this.accounts.delete(account);
+        this.emit('accountRemoved', account);
+        this.logger.info(`Account ${account} removed successfully`);
+    }
+    /**
+     * Get a specific account instance
+     *
+     * @param account - Phone number of the account
+     * @returns The SignalCli instance
+     */
+    getAccount(account) {
+        return this.accounts.get(account)?.instance;
+    }
+    /**
+     * Get all managed accounts
+     *
+     * @returns Array of account phone numbers
+     */
+    getAccounts() {
+        return Array.from(this.accounts.keys());
+    }
+    /**
+     * Check if an account exists
+     *
+     * @param account - Phone number of the account
+     * @returns True if the account exists
+     */
+    hasAccount(account) {
+        return this.accounts.has(account);
+    }
+    /**
+     * Connect a specific account
+     *
+     * @param account - Phone number of the account
+     */
+    async connect(account) {
+        const managedAccount = this.accounts.get(account);
+        if (!managedAccount) {
+            throw new Error(`Account ${account} not found`);
+        }
+        if (managedAccount.connected) {
+            this.logger.warn(`Account ${account} already connected`);
+            return;
+        }
+        this.logger.info(`Connecting account: ${account}`);
+        try {
+            await managedAccount.instance.connect();
+            managedAccount.connected = true;
+            managedAccount.lastActivity = Date.now();
+            this.emit('accountConnected', account);
+            this.logger.info(`Account ${account} connected successfully`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to connect account ${account}:`, error);
+            if (this.options.autoReconnect) {
+                this.logger.info(`Will retry connection for ${account}`);
+                setTimeout(() => this.connect(account), 5000);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Disconnect a specific account
+     *
+     * @param account - Phone number of the account
+     */
+    async disconnect(account) {
+        const managedAccount = this.accounts.get(account);
+        if (!managedAccount) {
+            throw new Error(`Account ${account} not found`);
+        }
+        if (!managedAccount.connected) {
+            this.logger.warn(`Account ${account} not connected`);
+            return;
+        }
+        this.logger.info(`Disconnecting account: ${account}`);
+        await managedAccount.instance.disconnect();
+        managedAccount.connected = false;
+        this.emit('accountDisconnected', account);
+        this.logger.info(`Account ${account} disconnected`);
+    }
+    /**
+     * Connect all accounts
+     */
+    async connectAll() {
+        this.logger.info('Connecting all accounts');
+        const promises = Array.from(this.accounts.keys()).map(account => this.connect(account).catch(error => {
+            this.logger.error(`Failed to connect ${account}:`, error);
+        }));
+        await Promise.all(promises);
+        this.logger.info('All accounts connected');
+    }
+    /**
+     * Disconnect all accounts
+     */
+    async disconnectAll() {
+        this.logger.info('Disconnecting all accounts');
+        const promises = Array.from(this.accounts.keys()).map(account => this.disconnect(account).catch(error => {
+            this.logger.error(`Failed to disconnect ${account}:`, error);
+        }));
+        await Promise.all(promises);
+        this.logger.info('All accounts disconnected');
+    }
+    /**
+     * Send a message from a specific account
+     *
+     * @param fromAccount - Account to send from
+     * @param recipient - Recipient phone number or group ID
+     * @param message - Message text
+     * @param options - Send options
+     */
+    async sendMessage(fromAccount, recipient, message, options = {}) {
+        const managedAccount = this.accounts.get(fromAccount);
+        if (!managedAccount) {
+            throw new Error(`Account ${fromAccount} not found`);
+        }
+        managedAccount.lastActivity = Date.now();
+        return managedAccount.instance.sendMessage(recipient, message, options);
+    }
+    /**
+     * Get account status information
+     *
+     * @param account - Phone number of the account (optional)
+     * @returns Status information for all or specific account
+     */
+    getStatus(account) {
+        if (account) {
+            const managedAccount = this.accounts.get(account);
+            if (!managedAccount) {
+                return null;
+            }
+            return {
+                account: managedAccount.account,
+                connected: managedAccount.connected,
+                lastActivity: managedAccount.lastActivity,
+                uptime: Date.now() - managedAccount.lastActivity
+            };
+        }
+        // Return status for all accounts
+        const status = {
+            totalAccounts: this.accounts.size,
+            connectedAccounts: 0,
+            accounts: []
+        };
+        for (const [account, managed] of this.accounts) {
+            if (managed.connected) {
+                status.connectedAccounts++;
+            }
+            status.accounts.push({
+                account,
+                connected: managed.connected,
+                lastActivity: managed.lastActivity,
+                uptime: Date.now() - managed.lastActivity
+            });
+        }
+        return status;
+    }
+    /**
+     * Setup event forwarding from an account instance
+     *
+     * @private
+     */
+    setupEventForwarding(account, instance) {
+        // Forward all events with account prefix
+        const events = [
+            'message',
+            'receipt',
+            'typing',
+            'reaction',
+            'error',
+            'connected',
+            'disconnected'
+        ];
+        events.forEach(event => {
+            instance.on(event, (...args) => {
+                // Emit with account information
+                this.emit(event, account, ...args);
+                // Also emit a generic event with account
+                this.emit('accountEvent', {
+                    account,
+                    event,
+                    data: args
+                });
+                // Update last activity
+                const managedAccount = this.accounts.get(account);
+                if (managedAccount) {
+                    managedAccount.lastActivity = Date.now();
+                }
+            });
+        });
+        // Handle disconnection
+        instance.on('disconnected', () => {
+            const managedAccount = this.accounts.get(account);
+            if (managedAccount) {
+                managedAccount.connected = false;
+            }
+            // Auto-reconnect if enabled
+            if (this.options.autoReconnect) {
+                this.logger.info(`Auto-reconnecting account ${account}`);
+                setTimeout(() => this.connect(account), 5000);
+            }
+        });
+    }
+    /**
+     * Shutdown the manager and cleanup all accounts
+     */
+    async shutdown() {
+        this.logger.info('Shutting down MultiAccountManager');
+        await this.disconnectAll();
+        // Remove all accounts
+        for (const account of this.accounts.keys()) {
+            await this.removeAccount(account);
+        }
+        this.removeAllListeners();
+        this.logger.info('MultiAccountManager shutdown complete');
+    }
+}
+exports.MultiAccountManager = MultiAccountManager;

package/dist/SignalBot.d.ts

@@ -12,6 +12,7 @@ export declare class SignalBot extends EventEmitter {
     private actionQueue;
     private isProcessingQueue;
     private incomingMessageBuffer;
+    private activeTimers;
     constructor(config: BotConfig, signalCliPath?: string);
     /**
      * Downloads an image from URL to a temporary file

package/dist/SignalBot.js

@@ -50,6 +50,7 @@ class SignalBot extends events_1.EventEmitter {
         this.actionQueue = [];
         this.isProcessingQueue = false;
         this.incomingMessageBuffer = [];
+        this.activeTimers = [];
         this.config = {
             phoneNumber: config.phoneNumber,
             admins: config.admins || [],
@@ -317,6 +318,9 @@ class SignalBot extends events_1.EventEmitter {
     async stop() {
         this.log('- Stopping Signal Bot...');
         this.isRunning = false;
+        // Clear all active timers
+        this.activeTimers.forEach(timer => clearTimeout(timer));
+        this.activeTimers = [];
         this.signalCli.disconnect();
         this.emit('stopped');
         this.log('- Bot stopped');
@@ -324,6 +328,9 @@ class SignalBot extends events_1.EventEmitter {
     async gracefulShutdown() {
         this.log('- Gracefully shutting down Signal Bot...');
         this.isRunning = false;
+        // Clear all active timers
+        this.activeTimers.forEach(timer => clearTimeout(timer));
+        this.activeTimers = [];
         try {
             await this.signalCli.gracefulShutdown();
             this.log('- Signal Bot shutdown completed gracefully');
@@ -725,11 +732,18 @@ class SignalBot extends events_1.EventEmitter {
                             // Wait a bit for signal-cli to finish processing the files before cleanup
                             // signal-cli responds immediately but continues processing files in background
                             if (action.cleanup && action.cleanup.length > 0) {
-                                setTimeout(() => {
+                                const cleanupTimer = setTimeout(() => {
                                     action.cleanup.forEach(filePath => {
                                         this.cleanupTempFile(filePath);
                                     });
+                                    // Remove timer from active list
+                                    const index = this.activeTimers.indexOf(cleanupTimer);
+                                    if (index > -1)
+                                        this.activeTimers.splice(index, 1);
                                 }, 2000); // Wait 2 seconds for signal-cli to upload files
+                                if (cleanupTimer.unref)
+                                    cleanupTimer.unref();
+                                this.activeTimers.push(cleanupTimer);
                             }
                             break;
                         case 'sendReaction':
@@ -738,7 +752,11 @@ class SignalBot extends events_1.EventEmitter {
                             break;
                     }
                     // Wait a bit between actions to be safe
-                    await new Promise(resolve => setTimeout(resolve, 250));
+                    await new Promise(resolve => {
+                        const timer = setTimeout(resolve, 250);
+                        if (timer.unref)
+                            timer.unref();
+                    });
                 }
                 catch (error) {
                     this.log(`ERROR: Failed to execute action ${action.type}: ${error?.message || error}`, 'ERROR');