@ipcom/asterisk-ari 0.0.67 → 0.0.69

package/dist/cjs/index.cjs

@@ -893,6 +893,7 @@ var ChannelInstance = class extends import_events2.EventEmitter {
     this.id = channelId || `channel-${Date.now()}`;
     this.baseClient.onWebSocketEvent((event) => {
       if (this.isChannelEvent(event) && event.channel?.id === this.channelId) {
+        console.log(`Evento recebido no ChannelInstance: ${event.type}`, event);
         this.emit(event.type, event);
       }
     });
@@ -905,7 +906,11 @@ var ChannelInstance = class extends import_events2.EventEmitter {
    * @param event Evento recebido.
    */
   isChannelEvent(event) {
-    return event && typeof event === "object" && "channel" in event;
+    const isChannelEvent2 = event && typeof event === "object" && "channel" in event && event.channel?.id === this.channelId;
+    if (!isChannelEvent2) {
+      console.log(`Evento ignorado no ChannelInstance: ${event.type}`, event);
+    }
+    return isChannelEvent2;
   }
   /**
    * Adiciona um listener para eventos de canal.
@@ -1703,18 +1708,19 @@ var AriClient = class {
     this.bridges = new Bridges(this.baseClient);
   }
   eventListeners = /* @__PURE__ */ new Map();
-  wsClient = null;
+  wsClients = /* @__PURE__ */ new Map();
+  // Map para armazenar conexões por app
   baseClient;
-  isReconnecting = false;
-  isWebSocketConnectedFlag = false;
-  webSocketReady = null;
-  // Promise para rastrear o estado do WebSocket
+  isReconnecting = /* @__PURE__ */ new Map();
+  // Estado de reconexão por app
+  webSocketReady = /* @__PURE__ */ new Map();
+  // Rastreamento do estado de cada conexão
   channelInstances = /* @__PURE__ */ new Map();
   pendingListeners = [];
   processPendingListeners() {
-    if (!this.wsClient || !this.isWebSocketConnectedFlag) {
+    if (this.wsClients.size === 0) {
       console.warn(
-        "WebSocket ainda n\xE3o est\xE1 pronto. N\xE3o \xE9 poss\xEDvel processar a fila."
+        "Nenhuma conex\xE3o WebSocket est\xE1 pronta. N\xE3o \xE9 poss\xEDvel processar a fila."
       );
       return;
     }
@@ -1724,7 +1730,12 @@ var AriClient = class {
     while (this.pendingListeners.length > 0) {
       const { event, callback } = this.pendingListeners.shift();
       console.log(`Registrando listener pendente para evento: ${event}`);
-      this.wsClient.on(event, callback);
+      for (const [app, wsClient] of this.wsClients.entries()) {
+        console.log(
+          `Registrando listener no app '${app}' para evento: ${event}`
+        );
+        wsClient.on(event, callback);
+      }
     }
   }
   channels;
@@ -1740,14 +1751,24 @@ var AriClient = class {
    * @param callback Callback a ser executado quando o evento for recebido.
    */
   onChannelEvent(eventType, callback) {
-    this.wsClient?.on(eventType, callback);
+    if (this.wsClients.size === 0) {
+      console.warn(
+        "Nenhuma conex\xE3o WebSocket est\xE1 ativa. O listener ser\xE1 pendente."
+      );
+      this.pendingListeners.push({ event: eventType, callback });
+      return;
+    }
+    for (const [app, wsClient] of this.wsClients.entries()) {
+      console.log(`Registrando evento '${eventType}' no app '${app}'`);
+      wsClient.on(eventType, callback);
+    }
   }
   /**
    * Registra um listener para eventos globais de WebSocket.
    * O channel no evento será automaticamente transformado em uma instância de ChannelInstance.
    */
   on(eventType, callback) {
-    console.log(`Registrando listener no AriClient para evento: ${eventType}`);
+    console.log(`Registrando listener global para evento: ${eventType}`);
     const wrappedCallback = (event) => {
       if (isChannelEvent(event)) {
         const channelId = event.channel.id;
@@ -1781,6 +1802,7 @@ var AriClient = class {
     return this.channels.createChannelInstance(channelId);
   }
   handleWebSocketEvent(event) {
+    console.log("Evento recebido no WebSocket:", event.type, event);
     const { type, ...data } = event;
     if (this.hasChannel(data)) {
       const channelId = data.channel.id;
@@ -1811,70 +1833,84 @@ var AriClient = class {
    * @returns A Promise that resolves when the WebSocket connection is successfully established and the application is registered.
    * @throws Error if the 'app' parameter is not provided, or if connection attempts fail after multiple retries.
    */
-  async connectWebSocket(app, subscribedEvents) {
+  /**
+   * Connects to the ARI WebSocket for one or more applications.
+   * Establishes a WebSocket connection for each app and subscribes to events.
+   *
+   * @param apps - Array of application names to connect to.
+   * @param subscribedEvents - Optional array of events to subscribe to.
+   *                           If not provided or empty, subscribes to all events.
+   * @returns A Promise that resolves when all connections are established.
+   */
+  async connectWebSocket(apps, subscribedEvents) {
+    if (!Array.isArray(apps) || apps.length === 0) {
+      throw new Error("\xC9 necess\xE1rio fornecer pelo menos um aplicativo.");
+    }
+    return Promise.all(
+      apps.map((app) => this.connectSingleWebSocket(app, subscribedEvents))
+    );
+  }
+  /**
+   * Establishes a single WebSocket connection for a given app.
+   */
+  async connectSingleWebSocket(app, subscribedEvents) {
     if (!app) {
-      throw new Error(
-        "O par\xE2metro 'app' \xE9 obrigat\xF3rio para conectar ao WebSocket."
-      );
+      throw new Error("O nome do aplicativo \xE9 obrigat\xF3rio.");
     }
-    if (this.webSocketReady) {
-      console.log("J\xE1 existe uma tentativa de conex\xE3o ativa. Aguardando...");
-      return this.webSocketReady;
+    if (this.webSocketReady.get(app)) {
+      console.log(`Conex\xE3o WebSocket para '${app}' j\xE1 est\xE1 ativa.`);
+      return this.webSocketReady.get(app);
     }
-    this.webSocketReady = new Promise(async (resolve, reject) => {
+    const protocol = this.config.secure ? "wss" : "ws";
+    const eventsParam = subscribedEvents && subscribedEvents.length > 0 ? `&event=${subscribedEvents.join(",")}` : "&subscribeAll=true";
+    const wsUrl = `${protocol}://${encodeURIComponent(
+      this.config.username
+    )}:${encodeURIComponent(this.config.password)}@${this.config.host}:${this.config.port}/ari/events?app=${app}${eventsParam}`;
+    const backoffOptions = {
+      delayFirstAttempt: false,
+      startingDelay: 1e3,
+      timeMultiple: 2,
+      maxDelay: 3e4,
+      numOfAttempts: 10,
+      jitter: "full",
+      retry: (error, attemptNumber) => {
+        console.warn(`Tentativa ${attemptNumber} falhou: ${error.message}`);
+        return Array.from(this.wsClients.values()).some(
+          (wsClient) => !wsClient.isConnected()
+        );
+      }
+    };
+    const webSocketPromise = new Promise(async (resolve, reject) => {
       try {
-        if (this.isReconnecting) {
-          console.warn(
-            "J\xE1 est\xE1 tentando reconectar. Ignorando esta tentativa."
-          );
+        if (this.isReconnecting.get(app)) {
+          console.warn(`J\xE1 est\xE1 tentando reconectar para o app '${app}'.`);
           return;
         }
-        this.isReconnecting = true;
-        const eventsParam = subscribedEvents && subscribedEvents.length > 0 ? `&event=${subscribedEvents.join(",")}` : "&subscribeAll=true";
-        const protocol = this.config.secure ? "wss" : "ws";
-        const wsUrl = `${protocol}://${encodeURIComponent(this.config.username)}:${encodeURIComponent(this.config.password)}@${this.config.host}:${this.config.port}/ari/events?app=${app}${eventsParam}`;
-        const backoffOptions = {
-          delayFirstAttempt: false,
-          startingDelay: 1e3,
-          timeMultiple: 2,
-          maxDelay: 3e4,
-          numOfAttempts: 10,
-          jitter: "full",
-          retry: (error, attemptNumber) => {
-            console.warn(`Tentativa ${attemptNumber} falhou: ${error.message}`);
-            return !this.wsClient?.isConnected();
-          }
-        };
-        if (this.wsClient?.isConnected()) {
-          console.log("WebSocket j\xE1 conectado. Removendo listeners antigos...");
-          this.wsClient.removeAllListeners();
-          this.wsClient.close();
-        }
-        this.wsClient = new WebSocketClient(wsUrl);
+        this.isReconnecting.set(app, true);
+        const wsClient = new WebSocketClient(wsUrl);
         await (0, import_exponential_backoff.backOff)(async () => {
-          if (!this.wsClient) {
+          if (!wsClient) {
             throw new Error("WebSocketClient instance is null.");
           }
-          await this.wsClient.connect();
-          this.integrateWebSocketEvents(app, this.wsClient);
+          await wsClient.connect();
+          this.integrateWebSocketEvents(app, wsClient);
           console.log(`WebSocket conectado para o app: ${app}`);
           await this.ensureAppRegistered(app);
-          this.isWebSocketConnectedFlag = true;
-          this.processPendingListeners();
+          this.wsClients.set(app, wsClient);
         }, backoffOptions);
         resolve();
-      } catch (err) {
+      } catch (error) {
         console.error(
-          "N\xE3o foi poss\xEDvel conectar ao WebSocket ap\xF3s m\xFAltiplas tentativas:",
-          err
+          `Erro ao conectar o WebSocket para o app '${app}':`,
+          error
         );
-        reject(err);
+        reject(error);
       } finally {
-        this.isReconnecting = false;
-        this.webSocketReady = null;
+        this.isReconnecting.delete(app);
       }
     });
-    return this.webSocketReady;
+    this.webSocketReady.set(app, webSocketPromise);
+    return webSocketPromise;
   }
   /**
    * Integrates WebSocket events with playback listeners.
@@ -1946,8 +1982,14 @@ var AriClient = class {
    *
    * @returns {boolean} True if connected, false otherwise.
    */
-  isWebSocketConnected() {
-    return this.wsClient ? this.wsClient.isConnected() : false;
+  anyWebSocketConnected() {
+    return Array.from(this.wsClients.values()).every(
+      (wsClient) => wsClient.isConnected()
+    );
+  }
+  isWebSocketConnected(app) {
+    const wsClient = this.wsClients.get(app);
+    return wsClient ? wsClient.isConnected() : false;
   }
   /**
    * Closes the WebSocket connection and removes all associated listeners.
@@ -1959,12 +2001,24 @@ var AriClient = class {
    *
    * @returns {void} This function doesn't return a value.
    */
-  closeWebSocket() {
-    if (this.wsClient) {
-      this.wsClient.close();
-      this.wsClient = null;
+  closeWebSocket(app) {
+    const wsClient = this.wsClients.get(app);
+    if (wsClient) {
+      wsClient.close();
+      this.wsClients.delete(app);
+      console.log(`WebSocket para o app '${app}' foi fechado.`);
+    } else {
+      console.warn(`WebSocket para o app '${app}' n\xE3o encontrado.`);
     }
   }
+  closeAllWebSockets() {
+    this.wsClients.forEach((wsClient, app) => {
+      wsClient.close();
+      console.log(`WebSocket para o app '${app}' foi fechado.`);
+    });
+    this.wsClients.clear();
+    console.log("Todos os WebSockets foram fechados.");
+  }
   /**
    * Retrieves a list of active channels from the Asterisk ARI.
    *