Merge remote-tracking branch 'upstream/develop' into bugfix/media-upload-failed-on-all-hosts

# Conflicts: # package-lock.json # src/utils/makeProxyAgent.ts
2025-12-09 01:49:37 -06:00 · 2025-11-24 13:58:25 -03:00 · 2025-11-24 13:58:25 -03:00 · 1c61116a3e
commit 1c61116a3e
parent ea88edd512 13f96a366b
31 changed files with 2373 additions and 1606 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@ -59,7 +59,7 @@ body:
      value: |
        - OS: [e.g. Ubuntu 20.04, Windows 10, macOS 12.0]
        - Node.js version: [e.g. 18.17.0]
-        - Evolution API version: [e.g. 2.3.6]
+        - Evolution API version: [e.g. 2.3.7]
        - Database: [e.g. PostgreSQL 14, MySQL 8.0]
        - Connection type: [e.g. Baileys, WhatsApp Business API]
    validations:
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,3 +1,71 @@
+# 2.3.7 (develop)
+
+### Features
+
+* **WhatsApp Business Meta Templates**: Add update and delete endpoints for Meta templates
+  - New endpoints to edit and delete WhatsApp Business templates
+  - Added DTOs and validation schemas for template management
+  - Enhanced template lifecycle management capabilities
+
+### Fixed
+
+* **Baileys Message Processor**: Fix incoming message events not working after reconnection
+  - Added cleanup logic in mount() to prevent memory leaks from multiple subscriptions
+  - Recreate messageSubject if it was completed during logout
+  - Remount messageProcessor in connectToWhatsapp() to ensure subscription is active
+  - Fixed issue where onDestroy() calls complete() on RxJS Subject, making it permanently closed
+  - Ensures old subscriptions are properly cleaned up before creating new ones
+
+* **Baileys Authentication**: Resolve "waiting for message" state after reconnection
+  - Fixed Redis keys not being properly removed during instance logout
+  - Prevented loading of old/invalid cryptographic keys on reconnection
+  - Fixed blocking state where instances authenticate but cannot send messages
+  - Ensures new credentials (creds) are properly used after reconnection
+
+* **OnWhatsapp Cache**: Prevent unique constraint errors and optimize database writes
+  - Fixed `Unique constraint failed on the fields: (remoteJid)` error when sending to groups
+  - Refactored query to use OR condition finding by jidOptions or remoteJid
+  - Added deep comparison to skip unnecessary database updates
+  - Replaced sequential processing with Promise.allSettled for parallel execution
+  - Sorted JIDs alphabetically in jidOptions for accurate change detection
+  - Added normalizeJid helper function for cleaner code
+
+* **Proxy Integration**: Fix "Media upload failed on all hosts" error when using proxy
+  - Created makeProxyAgentUndici() for Undici-compatible proxy agents
+  - Fixed compatibility with Node.js 18+ native fetch() implementation
+  - Replaced traditional HttpsProxyAgent/SocksProxyAgent with Undici ProxyAgent
+  - Maintained legacy makeProxyAgent() for Axios compatibility
+  - Fixed protocol handling in makeProxyAgent to prevent undefined errors
+
+* **WhatsApp Business API**: Fix base64, filename and caption handling
+  - Corrected base64 media conversion in Business API
+  - Fixed filename handling for document messages
+  - Improved caption processing for media messages
+  - Enhanced remoteJid validation and processing
+
+* **Chat Service**: Fix fetchChats and message panel errors
+  - Fixed cleanMessageData errors in Manager message panel
+  - Improved chat fetching reliability
+  - Enhanced message data sanitization
+
+* **Contact Filtering**: Apply where filters correctly in findContacts endpoint
+  - Fixed endpoint to process all where clause fields (id, remoteJid, pushName)
+  - Previously only processed remoteJid field, ignoring other filters
+  - Added remoteJid field to contactValidateSchema for proper validation
+  - Maintained multi-tenant isolation with instanceId filtering
+  - Allows filtering contacts by any supported field instead of returning all contacts
+
+* **Chatwoot and Baileys Integration**: Multiple integration improvements
+  - Enhanced code formatting and consistency
+  - Fixed integration issues between Chatwoot and Baileys services
+  - Improved message handling and delivery
+
+### Code Quality & Refactoring
+
+* **Template Management**: Remove unused template edit/delete DTOs after refactoring
+* **Proxy Utilities**: Improve makeProxyAgent for Undici compatibility
+* **Code Formatting**: Enhance code formatting and consistency across services
+
 # 2.3.6 (2025-10-21)

 ### Features
--- a/Docker/swarm/evolution_api_v2.yaml
+++ b/Docker/swarm/evolution_api_v2.yaml
@ -2,7 +2,7 @@ version: "3.7"

 services:
  evolution_v2:
-    image: evoapicloud/evolution-api:v2.3.6
+    image: evoapicloud/evolution-api:v2.3.7
    volumes:
      - evolution_instances:/evolution/instances
    networks:
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "evolution-api",
-  "version": "2.3.6",
+  "version": "2.3.7",
  "description": "Rest api for communication with WhatsApp",
  "main": "./dist/main.js",
  "type": "commonjs",
@ -77,7 +77,7 @@
    "amqplib": "^0.10.5",
    "audio-decode": "^2.2.3",
    "axios": "^1.7.9",
-    "baileys": "7.0.0-rc.6",
+    "baileys": "7.0.0-rc.9",
    "class-validator": "^0.14.1",
    "compression": "^1.7.5",
    "cors": "^2.8.5",
@ -97,6 +97,7 @@
    "jsonschema": "^1.4.1",
    "jsonwebtoken": "^9.0.2",
    "kafkajs": "^2.2.4",
+    "libphonenumber-js": "^1.12.25",
    "link-preview-js": "^3.0.13",
    "long": "^5.2.3",
    "mediainfo.js": "^0.3.4",
--- a/src/api/controllers/instance.controller.ts
+++ b/src/api/controllers/instance.controller.ts
@ -92,6 +92,15 @@ export class InstanceController {
        instanceId: instanceId,
      });

+      const instanceDto: InstanceDto = {
+        instanceName: instance.instanceName,
+        instanceId: instance.instanceId,
+        connectionStatus:
+          typeof instance.connectionStatus === 'string'
+            ? instance.connectionStatus
+            : instance.connectionStatus?.state || 'unknown',
+      };
+
      if (instanceData.proxyHost && instanceData.proxyPort && instanceData.proxyProtocol) {
        const testProxy = await this.proxyService.testProxy({
          host: instanceData.proxyHost,
@ -103,8 +112,7 @@ export class InstanceController {
        if (!testProxy) {
          throw new BadRequestException('Invalid proxy');
        }
-
-        await this.proxyService.createProxy(instance, {
+        await this.proxyService.createProxy(instanceDto, {
          enabled: true,
          host: instanceData.proxyHost,
          port: instanceData.proxyPort,
@ -125,7 +133,7 @@ export class InstanceController {
        wavoipToken: instanceData.wavoipToken || '',
      };

-      await this.settingsService.create(instance, settings);
+      await this.settingsService.create(instanceDto, settings);

      let webhookWaBusiness = null,
        accessTokenWaBusiness = '';
@ -155,7 +163,10 @@ export class InstanceController {
            integration: instanceData.integration,
            webhookWaBusiness,
            accessTokenWaBusiness,
-            status: instance.connectionStatus.state,
+            status:
+              typeof instance.connectionStatus === 'string'
+                ? instance.connectionStatus
+                : instance.connectionStatus?.state || 'unknown',
          },
          hash,
          webhook: {
@ -217,7 +228,7 @@ export class InstanceController {
      const urlServer = this.configService.get<HttpServer>('SERVER').URL;

      try {
-        this.chatwootService.create(instance, {
+        this.chatwootService.create(instanceDto, {
          enabled: true,
          accountId: instanceData.chatwootAccountId,
          token: instanceData.chatwootToken,
@ -246,7 +257,10 @@ export class InstanceController {
          integration: instanceData.integration,
          webhookWaBusiness,
          accessTokenWaBusiness,
-          status: instance.connectionStatus.state,
+          status:
+            typeof instance.connectionStatus === 'string'
+              ? instance.connectionStatus
+              : instance.connectionStatus?.state || 'unknown',
        },
        hash,
        webhook: {
@ -338,20 +352,38 @@ export class InstanceController {
        throw new BadRequestException('The "' + instanceName + '" instance does not exist');
      }

-      if (state == 'close') {
+      if (state === 'close') {
        throw new BadRequestException('The "' + instanceName + '" instance is not connected');
-      } else if (state == 'open') {
+      }
+      this.logger.info(`Restarting instance: ${instanceName}`);
+
+      if (typeof instance.restart === 'function') {
+        await instance.restart();
+        // Wait a bit for the reconnection to be established
+        await new Promise((r) => setTimeout(r, 2000));
+        return {
+          instance: {
+            instanceName: instanceName,
+            status: instance.connectionStatus?.state || 'connecting',
+          },
+        };
+      }
+
+      // Fallback for Baileys (uses different mechanism)
+      if (state === 'open' || state === 'connecting') {
        if (this.configService.get<Chatwoot>('CHATWOOT').ENABLED) instance.clearCacheChatwoot();
-        this.logger.info('restarting instance' + instanceName);

-        instance.client?.ws?.close();
-        instance.client?.end(new Error('restart'));
-        return await this.connectToWhatsapp({ instanceName });
-      } else if (state == 'connecting') {
        instance.client?.ws?.close();
        instance.client?.end(new Error('restart'));
        return await this.connectToWhatsapp({ instanceName });
      }
+
+      return {
+        instance: {
+          instanceName: instanceName,
+          status: state,
+        },
+      };
    } catch (error) {
      this.logger.error(error);
      return { error: true, message: error.toString() };
@ -409,7 +441,7 @@ export class InstanceController {
    }

    try {
-      this.waMonitor.waInstances[instanceName]?.logoutInstance();
+      await this.waMonitor.waInstances[instanceName]?.logoutInstance();

      return { status: 'SUCCESS', error: false, response: { message: 'Instance logged out' } };
    } catch (error) {
--- a/src/api/controllers/template.controller.ts
+++ b/src/api/controllers/template.controller.ts
@ -12,4 +12,15 @@ export class TemplateController {
  public async findTemplate(instance: InstanceDto) {
    return this.templateService.find(instance);
  }
+
+  public async editTemplate(
+    instance: InstanceDto,
+    data: { templateId: string; category?: string; components?: any; allowCategoryChange?: boolean; ttl?: number },
+  ) {
+    return this.templateService.edit(instance, data);
+  }
+
+  public async deleteTemplate(instance: InstanceDto, data: { name: string; hsmId?: string }) {
+    return this.templateService.delete(instance, data);
+  }
 }
--- a/src/api/dto/instance.dto.ts
+++ b/src/api/dto/instance.dto.ts
@ -12,6 +12,7 @@ export class InstanceDto extends IntegrationDto {
  token?: string;
  status?: string;
  ownerJid?: string;
+  connectionStatus?: string;
  profileName?: string;
  profilePicUrl?: string;
  // settings
--- a/src/api/dto/template.dto.ts
+++ b/src/api/dto/template.dto.ts
@ -6,3 +6,16 @@ export class TemplateDto {
  components: any;
  webhookUrl?: string;
 }
+
+export class TemplateEditDto {
+  templateId: string;
+  category?: 'AUTHENTICATION' | 'MARKETING' | 'UTILITY';
+  allowCategoryChange?: boolean;
+  ttl?: number;
+  components?: any;
+}
+
+export class TemplateDeleteDto {
+  name: string;
+  hsmId?: string;
+}
--- a/src/api/integrations/channel/meta/whatsapp.business.service.ts
+++ b/src/api/integrations/channel/meta/whatsapp.business.service.ts
@ -516,7 +516,9 @@ export class BusinessStartupService extends ChannelStartupService {
                const mediaUrl = await s3Service.getObjectUrl(fullName);

                messageRaw.message.mediaUrl = mediaUrl;
-                messageRaw.message.base64 = buffer.data.toString('base64');
+                if (this.localWebhook.enabled && this.localWebhook.webhookBase64) {
+                  messageRaw.message.base64 = buffer.data.toString('base64');
+                }

                // Processar OpenAI speech-to-text para áudio após o mediaUrl estar disponível
                if (this.configService.get<Openai>('OPENAI').ENABLED && mediaType === 'audio') {
@ -554,11 +556,19 @@ export class BusinessStartupService extends ChannelStartupService {
              this.logger.error(['Error on upload file to minio', error?.message, error?.stack]);
            }
          } else {
-            const buffer = await this.downloadMediaMessage(received?.messages[0]);
-            messageRaw.message.base64 = buffer.toString('base64');
+            if (this.localWebhook.enabled && this.localWebhook.webhookBase64) {
+              const buffer = await this.downloadMediaMessage(received?.messages[0]);
+              messageRaw.message.base64 = buffer.toString('base64');
+            }

            // Processar OpenAI speech-to-text para áudio mesmo sem S3
            if (this.configService.get<Openai>('OPENAI').ENABLED && message.type === 'audio') {
+              let openAiBase64 = messageRaw.message.base64;
+              if (!openAiBase64) {
+                const buffer = await this.downloadMediaMessage(received?.messages[0]);
+                openAiBase64 = buffer.toString('base64');
+              }
+
              const openAiDefaultSettings = await this.prismaRepository.openaiSetting.findFirst({
                where: {
                  instanceId: this.instanceId,
@ -574,7 +584,7 @@ export class BusinessStartupService extends ChannelStartupService {
                    openAiDefaultSettings.OpenaiCreds,
                    {
                      message: {
-                        base64: messageRaw.message.base64,
+                        base64: openAiBase64,
                        ...messageRaw,
                      },
                    },
@ -1016,6 +1026,7 @@ export class BusinessStartupService extends ChannelStartupService {
            [message['mediaType']]: {
              [message['type']]: message['id'],
              ...(message['mediaType'] !== 'audio' &&
+                message['mediaType'] !== 'video' &&
                message['fileName'] &&
                !isImage && { filename: message['fileName'] }),
              ...(message['mediaType'] !== 'audio' && message['caption'] && { caption: message['caption'] }),
@ -1606,9 +1617,14 @@ export class BusinessStartupService extends ChannelStartupService {
      const messageType = msg.messageType.includes('Message') ? msg.messageType : msg.messageType + 'Message';
      const mediaMessage = msg.message[messageType];

+      if (!msg.message?.base64) {
+        const buffer = await this.downloadMediaMessage({ type: messageType, ...msg.message });
+        msg.message.base64 = buffer.toString('base64');
+      }
+
      return {
        mediaType: msg.messageType,
-        fileName: mediaMessage?.fileName,
+        fileName: mediaMessage?.fileName || mediaMessage?.filename,
        caption: mediaMessage?.caption,
        size: {
          fileLength: mediaMessage?.fileLength,
--- a/src/api/integrations/channel/whatsapp/baileysMessage.processor.ts
+++ b/src/api/integrations/channel/whatsapp/baileysMessage.processor.ts
@ -19,6 +19,22 @@ export class BaileysMessageProcessor {
  }>();

  mount({ onMessageReceive }: MountProps) {
+    // Se já existe subscription, fazer cleanup primeiro
+    if (this.subscription && !this.subscription.closed) {
+      this.subscription.unsubscribe();
+    }
+
+    // Se o Subject foi completado, recriar
+    if (this.messageSubject.closed) {
+      this.processorLogs.warn('MessageSubject was closed, recreating...');
+      this.messageSubject = new Subject<{
+        messages: WAMessage[];
+        type: MessageUpsertType;
+        requestId?: string;
+        settings: any;
+      }>();
+    }
+
    this.subscription = this.messageSubject
      .pipe(
        tap(({ messages }) => {
--- a/src/api/integrations/channel/whatsapp/whatsapp.baileys.service.ts
+++ b/src/api/integrations/channel/whatsapp/whatsapp.baileys.service.ts
@ -266,6 +266,28 @@ export class BaileysStartupService extends ChannelStartupService {

    this.client?.ws?.close();

+    const db = this.configService.get<Database>('DATABASE');
+    const cache = this.configService.get<CacheConf>('CACHE');
+    const provider = this.configService.get<ProviderSession>('PROVIDER');
+
+    if (provider?.ENABLED) {
+      const authState = await this.authStateProvider.authStateProvider(this.instance.id);
+
+      await authState.removeCreds();
+    }
+
+    if (cache?.REDIS.ENABLED && cache?.REDIS.SAVE_INSTANCES) {
+      const authState = await useMultiFileAuthStateRedisDb(this.instance.id, this.cache);
+
+      await authState.removeCreds();
+    }
+
+    if (db.SAVE_DATA.INSTANCE) {
+      const authState = await useMultiFileAuthStatePrisma(this.instance.id, this.cache);
+
+      await authState.removeCreds();
+    }
+
    const sessionExists = await this.prismaRepository.session.findFirst({ where: { sessionId: this.instanceId } });
    if (sessionExists) {
      await this.prismaRepository.session.delete({ where: { sessionId: this.instanceId } });
@ -569,15 +591,6 @@ export class BaileysStartupService extends ChannelStartupService {
    const version = baileysVersion.version;
    const log = `Baileys version: ${version.join('.')}`;

-    // if (session.VERSION) {
-    //   version = session.VERSION.split('.');
-    //   log = `Baileys version env: ${version}`;
-    // } else {
-    //   const baileysVersion = await fetchLatestWaWebVersion({});
-    //   version = baileysVersion.version;
-    //   log = `Baileys version: ${version}`;
-    // }
-
    this.logger.info(log);

    this.logger.info(`Group Ignore: ${this.localSettings.groupsIgnore}`);
@ -710,6 +723,11 @@ export class BaileysStartupService extends ChannelStartupService {
      this.loadWebhook();
      this.loadProxy();

+      // Remontar o messageProcessor para garantir que está funcionando após reconexão
+      this.messageProcessor.mount({
+        onMessageReceive: this.messageHandle['messages.upsert'].bind(this),
+      });
+
      return await this.createClient(number);
    } catch (error) {
      this.logger.error(error);
@ -1130,16 +1148,6 @@ export class BaileysStartupService extends ChannelStartupService {
            }
          }

-          const messageKey = `${this.instance.id}_${received.key.id}`;
-          const cached = await this.baileysCache.get(messageKey);
-
-          if (cached && !editedMessage && !requestId) {
-            this.logger.info(`Message duplicated ignored: ${received.key.id}`);
-            continue;
-          }
-
-          await this.baileysCache.set(messageKey, true, this.MESSAGE_CACHE_TTL_SECONDS);
-
          if (
            (type !== 'notify' && type !== 'append') ||
            editedMessage ||
@ -1349,6 +1357,10 @@ export class BaileysStartupService extends ChannelStartupService {
          this.logger.verbose(messageRaw);

          sendTelemetry(`received.message.${messageRaw.messageType ?? 'unknown'}`);
+          if (messageRaw.key.remoteJid?.includes('@lid') && messageRaw.key.remoteJidAlt) {
+            messageRaw.key.remoteJid = messageRaw.key.remoteJidAlt;
+          }
+          console.log(messageRaw);

          this.sendDataWebhook(Events.MESSAGES_UPSERT, messageRaw);

@ -1442,7 +1454,7 @@ export class BaileysStartupService extends ChannelStartupService {
        const cached = await this.baileysCache.get(updateKey);

        if (cached) {
-          this.logger.info(`Message duplicated ignored [avoid deadlock]: ${updateKey}`);
+          this.logger.info(`Update Message duplicated ignored [avoid deadlock]: ${updateKey}`);
          continue;
        }

--- a/src/api/integrations/chatbot/chatwoot/controllers/chatwoot.controller.ts
+++ b/src/api/integrations/chatbot/chatwoot/controllers/chatwoot.controller.ts
@ -1,10 +1,6 @@
 import { InstanceDto } from '@api/dto/instance.dto';
 import { ChatwootDto } from '@api/integrations/chatbot/chatwoot/dto/chatwoot.dto';
 import { ChatwootService } from '@api/integrations/chatbot/chatwoot/services/chatwoot.service';
-import { PrismaRepository } from '@api/repository/repository.service';
-import { waMonitor } from '@api/server.module';
-import { CacheService } from '@api/services/cache.service';
-import { CacheEngine } from '@cache/cacheengine';
 import { Chatwoot, ConfigService, HttpServer } from '@config/env.config';
 import { BadRequestException } from '@exceptions';
 import { isURL } from 'class-validator';
@ -13,7 +9,6 @@ export class ChatwootController {
  constructor(
    private readonly chatwootService: ChatwootService,
    private readonly configService: ConfigService,
-    private readonly prismaRepository: PrismaRepository,
  ) {}

  public async createChatwoot(instance: InstanceDto, data: ChatwootDto) {
@ -84,9 +79,6 @@ export class ChatwootController {
  public async receiveWebhook(instance: InstanceDto, data: any) {
    if (!this.configService.get<Chatwoot>('CHATWOOT').ENABLED) throw new BadRequestException('Chatwoot is disabled');

-    const chatwootCache = new CacheService(new CacheEngine(this.configService, ChatwootService.name).getEngine());
-    const chatwootService = new ChatwootService(waMonitor, this.configService, this.prismaRepository, chatwootCache);
-
-    return chatwootService.receiveWebhook(instance, data);
+    return this.chatwootService.receiveWebhook(instance, data);
  }
 }
--- a/src/api/integrations/chatbot/chatwoot/services/chatwoot.service.ts
+++ b/src/api/integrations/chatbot/chatwoot/services/chatwoot.service.ts
@ -27,6 +27,7 @@ import { WAMessageContent, WAMessageKey } from 'baileys';
 import dayjs from 'dayjs';
 import FormData from 'form-data';
 import { Jimp, JimpMime } from 'jimp';
+import { parsePhoneNumberFromString } from 'libphonenumber-js';
 import Long from 'long';
 import mimeTypes from 'mime-types';
 import path from 'path';
@ -589,7 +590,7 @@ export class ChatwootService {
            `Identifier needs update: (contact.identifier: ${contact.identifier}, phoneNumber: ${phoneNumber}, body.key.remoteJidAlt: ${remoteJid}`,
          );
          const updateContact = await this.updateContact(instance, contact.id, {
-            identifier: remoteJid,
+            identifier: phoneNumber,
            phone_number: `+${phoneNumber.split('@')[0]}`,
          });

@ -611,13 +612,15 @@ export class ChatwootService {
      if (await this.cache.has(cacheKey)) {
        const conversationId = (await this.cache.get(cacheKey)) as number;
        this.logger.verbose(`Found conversation to: ${phoneNumber}, conversation ID: ${conversationId}`);
-        let conversationExists: conversation | boolean;
+        let conversationExists: any;
        try {
          conversationExists = await client.conversations.get({
            accountId: this.provider.accountId,
            conversationId: conversationId,
          });
-          this.logger.verbose(`Conversation exists: ${JSON.stringify(conversationExists)}`);
+          this.logger.verbose(
+            `Conversation exists: ID: ${conversationExists.id} - Name: ${conversationExists.meta.sender.name} - Identifier: ${conversationExists.meta.sender.identifier}`,
+          );
        } catch (error) {
          this.logger.error(`Error getting conversation: ${error}`);
          conversationExists = false;
@ -669,7 +672,7 @@ export class ChatwootService {
        if (isGroup) {
          this.logger.verbose(`Processing group conversation`);
          const group = await this.waMonitor.waInstances[instance.instanceName].client.groupMetadata(chatId);
-          this.logger.verbose(`Group metadata: ${JSON.stringify(group)}`);
+          this.logger.verbose(`Group metadata: JID:${group.JID} - Subject:${group?.subject || group?.Name}`);

          const participantJid = isLid && !body.key.fromMe ? body.key.participantAlt : body.key.participant;
          nameContact = `${group.subject} (GROUP)`;
@ -680,9 +683,11 @@ export class ChatwootService {
          this.logger.verbose(`Participant profile picture URL: ${JSON.stringify(picture_url)}`);

          const findParticipant = await this.findContact(instance, participantJid.split('@')[0]);
-          this.logger.verbose(`Found participant: ${JSON.stringify(findParticipant)}`);

          if (findParticipant) {
+            this.logger.verbose(
+              `Found participant: ID:${findParticipant.id} - Name: ${findParticipant.name} - identifier: ${findParticipant.identifier}`,
+            );
            if (!findParticipant.name || findParticipant.name === chatId) {
              await this.updateContact(instance, findParticipant.id, {
                name: body.pushName,
@ -692,7 +697,7 @@ export class ChatwootService {
          } else {
            await this.createContact(
              instance,
-              participantJid.split('@')[0],
+              participantJid.split('@')[0].split(':')[0],
              filterInbox.id,
              false,
              body.pushName,
@ -709,20 +714,13 @@ export class ChatwootService {
        let contact = await this.findContact(instance, chatId);

        if (contact) {
-          this.logger.verbose(`Found contact: ${JSON.stringify(contact)}`);
+          this.logger.verbose(`Found contact: ID:${contact.id} - Name:${contact.name}`);
          if (!body.key.fromMe) {
            const waProfilePictureFile =
              picture_url?.profilePictureUrl?.split('#')[0].split('?')[0].split('/').pop() || '';
            const chatwootProfilePictureFile = contact?.thumbnail?.split('#')[0].split('?')[0].split('/').pop() || '';
            const pictureNeedsUpdate = waProfilePictureFile !== chatwootProfilePictureFile;
-            const nameNeedsUpdate =
-              !contact.name ||
-              contact.name === chatId ||
-              (`+${chatId}`.startsWith('+55')
-                ? this.getNumbers(`+${chatId}`).some(
-                    (v) => contact.name === v || contact.name === v.substring(3) || contact.name === v.substring(1),
-                  )
-                : false);
+            const nameNeedsUpdate = !contact.name || contact.name === chatId;
            this.logger.verbose(`Picture needs update: ${pictureNeedsUpdate}`);
            this.logger.verbose(`Name needs update: ${nameNeedsUpdate}`);
            if (pictureNeedsUpdate || nameNeedsUpdate) {
@ -741,7 +739,7 @@ export class ChatwootService {
            isGroup,
            nameContact,
            picture_url.profilePictureUrl || null,
-            remoteJid,
+            phoneNumber,
          );
        }

@ -757,7 +755,6 @@ export class ChatwootService {
          accountId: this.provider.accountId,
          id: contactId,
        })) as any;
-        this.logger.verbose(`Contact conversations: ${JSON.stringify(contactConversations)}`);

        if (!contactConversations || !contactConversations.payload) {
          this.logger.error(`No conversations found or payload is undefined`);
@ -769,7 +766,9 @@ export class ChatwootService {
        );
        if (inboxConversation) {
          if (this.provider.reopenConversation) {
-            this.logger.verbose(`Found conversation in reopenConversation mode: ${JSON.stringify(inboxConversation)}`);
+            this.logger.verbose(
+              `Found conversation in reopenConversation mode: ID: ${inboxConversation.id} - Name: ${inboxConversation.meta.sender.name} - Identifier: ${inboxConversation.meta.sender.identifier}`,
+            );
            if (inboxConversation && this.provider.conversationPending && inboxConversation.status !== 'open') {
              await client.conversations.toggleStatus({
                accountId: this.provider.accountId,
@ -789,7 +788,7 @@ export class ChatwootService {

          if (inboxConversation) {
            this.logger.verbose(`Returning existing conversation ID: ${inboxConversation.id}`);
-            this.cache.set(cacheKey, inboxConversation.id, 8 * 3600);
+            this.cache.set(cacheKey, inboxConversation.id, 1800);
            return inboxConversation.id;
          }
        }
@ -803,14 +802,6 @@ export class ChatwootService {
          data['status'] = 'pending';
        }

-        /*
-        Triple check after lock
-        Utilizei uma nova verificação para evitar que outra thread execute entre o terminio do while e o set lock
-        */
-        if (await this.cache.has(cacheKey)) {
-          return (await this.cache.get(cacheKey)) as number;
-        }
-
        const conversation = await client.conversations.create({
          accountId: this.provider.accountId,
          data,
@ -822,7 +813,7 @@ export class ChatwootService {
        }

        this.logger.verbose(`New conversation created of ${remoteJid} with ID: ${conversation.id}`);
-        this.cache.set(cacheKey, conversation.id, 8 * 3600);
+        this.cache.set(cacheKey, conversation.id, 1800);
        return conversation.id;
      } finally {
        await this.cache.delete(lockKey);
@ -1392,10 +1383,7 @@ export class ChatwootService {
      }

      if (body.message_type === 'outgoing' && body?.conversation?.messages?.length && chatId !== '123456') {
-        if (
-          body?.conversation?.messages[0]?.source_id?.substring(0, 5) === 'WAID:' &&
-          body?.conversation?.messages[0]?.id === body?.id
-        ) {
+        if (body?.conversation?.messages[0]?.source_id?.substring(0, 5) === 'WAID:') {
          return { message: 'bot' };
        }

@ -1666,6 +1654,10 @@ export class ChatwootService {
    return result;
  }

+  private isInteractiveButtonMessage(messageType: string, message: any) {
+    return messageType === 'interactiveMessage' && message.interactiveMessage?.nativeFlowMessage?.buttons?.length > 0;
+  }
+
  private getAdsMessage(msg: any) {
    interface AdsMessage {
      title: string;
@ -1984,8 +1976,9 @@ export class ChatwootService {
        const adsMessage = this.getAdsMessage(body);

        const reactionMessage = this.getReactionMessage(body.message);
+        const isInteractiveButtonMessage = this.isInteractiveButtonMessage(body.messageType, body.message);

-        if (!bodyMessage && !isMedia && !reactionMessage) {
+        if (!bodyMessage && !isMedia && !reactionMessage && !isInteractiveButtonMessage) {
          this.logger.warn('no body message found');
          return;
        }
@ -2032,17 +2025,9 @@ export class ChatwootService {
            const participantName = body.pushName;
            const rawPhoneNumber =
              body.key.addressingMode === 'lid' && !body.key.fromMe
-                ? body.key.participantAlt.split('@')[0]
-                : body.key.participant.split('@')[0];
-            const phoneMatch = rawPhoneNumber.match(/^(\d{2})(\d{2})(\d{4})(\d{4})$/);
-
-            let formattedPhoneNumber: string;
-
-            if (phoneMatch) {
-              formattedPhoneNumber = `+${phoneMatch[1]} (${phoneMatch[2]}) ${phoneMatch[3]}-${phoneMatch[4]}`;
-            } else {
-              formattedPhoneNumber = `+${rawPhoneNumber}`;
-            }
+                ? body.key.participantAlt.split('@')[0].split(':')[0]
+                : body.key.participant.split('@')[0].split(':')[0];
+            const formattedPhoneNumber = parsePhoneNumberFromString(`+${rawPhoneNumber}`).formatInternational();

            let content: string;

@ -2118,6 +2103,50 @@ export class ChatwootService {
          return;
        }

+        if (isInteractiveButtonMessage) {
+          const buttons = body.message.interactiveMessage.nativeFlowMessage.buttons;
+          this.logger.info('is Interactive Button Message: ' + JSON.stringify(buttons));
+
+          for (const button of buttons) {
+            const buttonParams = JSON.parse(button.buttonParamsJson);
+            const paymentSettings = buttonParams.payment_settings;
+
+            if (button.name === 'payment_info' && paymentSettings[0].type === 'pix_static_code') {
+              const pixSettings = paymentSettings[0].pix_static_code;
+              const pixKeyType = (() => {
+                switch (pixSettings.key_type) {
+                  case 'EVP':
+                    return 'Chave Aleatória';
+                  case 'EMAIL':
+                    return 'E-mail';
+                  case 'PHONE':
+                    return 'Telefone';
+                  default:
+                    return pixSettings.key_type;
+                }
+              })();
+              const pixKey = pixSettings.key_type === 'PHONE' ? pixSettings.key.replace('+55', '') : pixSettings.key;
+              const content = `*${pixSettings.merchant_name}*\nChave PIX: ${pixKey} (${pixKeyType})`;
+
+              const send = await this.createMessage(
+                instance,
+                getConversation,
+                content,
+                messageType,
+                false,
+                [],
+                body,
+                'WAID:' + body.key.id,
+                quotedMsg,
+              );
+              if (!send) this.logger.warn('message not sent');
+            } else {
+              this.logger.warn('Interactive Button Message not mapped');
+            }
+          }
+          return;
+        }
+
        const isAdsMessage = (adsMessage && adsMessage.title) || adsMessage.body || adsMessage.thumbnailUrl;
        if (isAdsMessage) {
          const imgBuffer = await axios.get(adsMessage.thumbnailUrl, { responseType: 'arraybuffer' });
@ -2178,17 +2207,9 @@ export class ChatwootService {
          const participantName = body.pushName;
          const rawPhoneNumber =
            body.key.addressingMode === 'lid' && !body.key.fromMe
-              ? body.key.participantAlt.split('@')[0]
-              : body.key.participant.split('@')[0];
-          const phoneMatch = rawPhoneNumber.match(/^(\d{2})(\d{2})(\d{4})(\d{4})$/);
-
-          let formattedPhoneNumber: string;
-
-          if (phoneMatch) {
-            formattedPhoneNumber = `+${phoneMatch[1]} (${phoneMatch[2]}) ${phoneMatch[3]}-${phoneMatch[4]}`;
-          } else {
-            formattedPhoneNumber = `+${rawPhoneNumber}`;
-          }
+              ? body.key.participantAlt.split('@')[0].split(':')[0]
+              : body.key.participant.split('@')[0].split(':')[0];
+          const formattedPhoneNumber = parsePhoneNumberFromString(`+${rawPhoneNumber}`).formatInternational();

          let content: string;

@ -2270,8 +2291,21 @@ export class ChatwootService {
      }

      if (event === 'messages.edit' || event === 'send.message.update') {
-        const editedMessageContent =
-          body?.editedMessage?.conversation || body?.editedMessage?.extendedTextMessage?.text;
+        const editedMessageContentRaw =
+          body?.editedMessage?.conversation ??
+          body?.editedMessage?.extendedTextMessage?.text ??
+          body?.editedMessage?.imageMessage?.caption ??
+          body?.editedMessage?.videoMessage?.caption ??
+          body?.editedMessage?.documentMessage?.caption ??
+          (typeof body?.text === 'string' ? body.text : undefined);
+
+        const editedMessageContent = (editedMessageContentRaw ?? '').trim();
+
+        if (!editedMessageContent) {
+          this.logger.info('[CW.EDIT] Conteúdo vazio — ignorando (DELETE tratará se for revoke).');
+          return;
+        }
+
        const message = await this.getMessageByKeyId(instance, body?.key?.id);

        if (!message) {
@ -2338,7 +2372,7 @@ export class ChatwootService {
            const url =
              `/public/api/v1/inboxes/${inbox.inbox_identifier}/contacts/${sourceId}` +
              `/conversations/${conversationId}/update_last_seen`;
-            chatwootRequest(this.getClientCwConfig(), {
+            await chatwootRequest(this.getClientCwConfig(), {
              method: 'POST',
              url: url,
            });
--- a/src/api/integrations/chatbot/chatwoot/utils/chatwoot-import-helper.ts
+++ b/src/api/integrations/chatbot/chatwoot/utils/chatwoot-import-helper.ts
@ -137,7 +137,7 @@ class ChatwootImport {
                       DO UPDATE SET
                        name = EXCLUDED.name,
                        phone_number = EXCLUDED.phone_number,
-                        identifier = EXCLUDED.identifier`;
+                        updated_at = NOW()`;

        totalContactsImported += (await pgClient.query(sqlInsert, bindInsert))?.rowCount ?? 0;

--- a/src/api/routes/index.router.ts
+++ b/src/api/routes/index.router.ts
@ -48,9 +48,14 @@ const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
 const metricsIPWhitelist = (req: Request, res: Response, next: NextFunction) => {
  const metricsConfig = configService.get('METRICS');
  const allowedIPs = metricsConfig.ALLOWED_IPS?.split(',').map((ip) => ip.trim()) || ['127.0.0.1'];
-  const clientIP = req.ip || req.connection.remoteAddress || req.socket.remoteAddress;
+  const clientIPs = [
+    req.ip,
+    req.connection.remoteAddress,
+    req.socket.remoteAddress,
+    req.headers['x-forwarded-for'],
+  ].filter((ip) => ip !== undefined);

-  if (!allowedIPs.includes(clientIP)) {
+  if (allowedIPs.filter((ip) => clientIPs.includes(ip)) === 0) {
    return res.status(403).send('Forbidden: IP not allowed');
  }

--- a/src/api/routes/template.router.ts
+++ b/src/api/routes/template.router.ts
@ -1,9 +1,11 @@
 import { RouterBroker } from '@api/abstract/abstract.router';
 import { InstanceDto } from '@api/dto/instance.dto';
-import { TemplateDto } from '@api/dto/template.dto';
+import { TemplateDeleteDto, TemplateDto, TemplateEditDto } from '@api/dto/template.dto';
 import { templateController } from '@api/server.module';
 import { ConfigService } from '@config/env.config';
 import { createMetaErrorResponse } from '@utils/errorResponse';
+import { templateDeleteSchema } from '@validate/templateDelete.schema';
+import { templateEditSchema } from '@validate/templateEdit.schema';
 import { instanceSchema, templateSchema } from '@validate/validate.schema';
 import { RequestHandler, Router } from 'express';

@ -35,6 +37,38 @@ export class TemplateRouter extends RouterBroker {
          res.status(errorResponse.status).json(errorResponse);
        }
      })
+      .post(this.routerPath('edit'), ...guards, async (req, res) => {
+        try {
+          const response = await this.dataValidate<TemplateEditDto>({
+            request: req,
+            schema: templateEditSchema,
+            ClassRef: TemplateEditDto,
+            execute: (instance, data) => templateController.editTemplate(instance, data),
+          });
+
+          res.status(HttpStatus.OK).json(response);
+        } catch (error) {
+          console.error('Template edit error:', error);
+          const errorResponse = createMetaErrorResponse(error, 'template_edit');
+          res.status(errorResponse.status).json(errorResponse);
+        }
+      })
+      .delete(this.routerPath('delete'), ...guards, async (req, res) => {
+        try {
+          const response = await this.dataValidate<TemplateDeleteDto>({
+            request: req,
+            schema: templateDeleteSchema,
+            ClassRef: TemplateDeleteDto,
+            execute: (instance, data) => templateController.deleteTemplate(instance, data),
+          });
+
+          res.status(HttpStatus.OK).json(response);
+        } catch (error) {
+          console.error('Template delete error:', error);
+          const errorResponse = createMetaErrorResponse(error, 'template_delete');
+          res.status(errorResponse.status).json(errorResponse);
+        }
+      })
      .get(this.routerPath('find'), ...guards, async (req, res) => {
        try {
          const response = await this.dataValidate<InstanceDto>({
--- a/src/api/server.module.ts
+++ b/src/api/server.module.ts
@ -82,7 +82,7 @@ const proxyService = new ProxyService(waMonitor);
 export const proxyController = new ProxyController(proxyService, waMonitor);

 const chatwootService = new ChatwootService(waMonitor, configService, prismaRepository, chatwootCache);
-export const chatwootController = new ChatwootController(chatwootService, configService, prismaRepository);
+export const chatwootController = new ChatwootController(chatwootService, configService);

 const settingsService = new SettingsService(waMonitor);
 export const settingsController = new SettingsController(settingsService);
--- a/src/api/services/channel.service.ts
+++ b/src/api/services/channel.service.ts
@ -60,6 +60,7 @@ export class ChannelStartupService {
    this.instance.number = instance.number;
    this.instance.token = instance.token;
    this.instance.businessId = instance.businessId;
+    this.instance.ownerJid = instance.ownerJid;

    if (this.configService.get<Chatwoot>('CHATWOOT').ENABLED && this.localChatwoot?.enabled) {
      this.chatwootService.eventWhatsapp(
@ -490,20 +491,23 @@ export class ChannelStartupService {
  }

  public async fetchContacts(query: Query<Contact>) {
-    const remoteJid = query?.where?.remoteJid
-      ? query?.where?.remoteJid.includes('@')
-        ? query.where?.remoteJid
-        : createJid(query.where?.remoteJid)
-      : null;
-
-    const where = {
+    const where: any = {
      instanceId: this.instanceId,
    };

-    if (remoteJid) {
+    if (query?.where?.remoteJid) {
+      const remoteJid = query.where.remoteJid.includes('@') ? query.where.remoteJid : createJid(query.where.remoteJid);
      where['remoteJid'] = remoteJid;
    }

+    if (query?.where?.id) {
+      where['id'] = query.where.id;
+    }
+
+    if (query?.where?.pushName) {
+      where['pushName'] = query.where.pushName;
+    }
+
    const contactFindManyArgs: Prisma.ContactFindManyArgs = {
      where,
    };
@ -532,14 +536,12 @@ export class ChannelStartupService {

  public cleanMessageData(message: any) {
    if (!message) return message;
-
    const cleanedMessage = { ...message };

-    const mediaUrl = cleanedMessage.message.mediaUrl;
-
-    delete cleanedMessage.message.base64;
-
    if (cleanedMessage.message) {
+      const { mediaUrl } = cleanedMessage.message;
+      delete cleanedMessage.message.base64;
+
      // Limpa imageMessage
      if (cleanedMessage.message.imageMessage) {
        cleanedMessage.message.imageMessage = {
@ -581,9 +583,9 @@ export class ChannelStartupService {
          name: cleanedMessage.message.documentWithCaptionMessage.name,
        };
      }
-    }

-    if (mediaUrl) cleanedMessage.message.mediaUrl = mediaUrl;
+      if (mediaUrl) cleanedMessage.message.mediaUrl = mediaUrl;
+    }

    return cleanedMessage;
  }
--- a/src/api/services/monitor.service.ts
+++ b/src/api/services/monitor.service.ts
@ -38,25 +38,37 @@ export class WAMonitoringService {

  private readonly logger = new Logger('WAMonitoringService');
  public readonly waInstances: Record<string, any> = {};
+  private readonly delInstanceTimeouts: Record<string, NodeJS.Timeout> = {};

  private readonly providerSession: ProviderSession;

  public delInstanceTime(instance: string) {
    const time = this.configService.get<DelInstance>('DEL_INSTANCE');
    if (typeof time === 'number' && time > 0) {
-      setTimeout(
+      // Clear previous timeout if exists
+      if (this.delInstanceTimeouts[instance]) {
+        clearTimeout(this.delInstanceTimeouts[instance]);
+      }
+
+      // Set new timeout and store reference
+      this.delInstanceTimeouts[instance] = setTimeout(
        async () => {
-          if (this.waInstances[instance]?.connectionStatus?.state !== 'open') {
-            if (this.waInstances[instance]?.connectionStatus?.state === 'connecting') {
-              if ((await this.waInstances[instance].integration) === Integration.WHATSAPP_BAILEYS) {
-                await this.waInstances[instance]?.client?.logout('Log out instance: ' + instance);
-                this.waInstances[instance]?.client?.ws?.close();
-                this.waInstances[instance]?.client?.end(undefined);
+          try {
+            if (this.waInstances[instance]?.connectionStatus?.state !== 'open') {
+              if (this.waInstances[instance]?.connectionStatus?.state === 'connecting') {
+                if ((await this.waInstances[instance].integration) === Integration.WHATSAPP_BAILEYS) {
+                  await this.waInstances[instance]?.client?.logout('Log out instance: ' + instance);
+                  this.waInstances[instance]?.client?.ws?.close();
+                  this.waInstances[instance]?.client?.end(undefined);
+                }
+                this.eventEmitter.emit('remove.instance', instance, 'inner');
+              } else {
+                this.eventEmitter.emit('remove.instance', instance, 'inner');
              }
-              this.eventEmitter.emit('remove.instance', instance, 'inner');
-            } else {
-              this.eventEmitter.emit('remove.instance', instance, 'inner');
            }
+          } finally {
+            // Clean up timeout reference
+            delete this.delInstanceTimeouts[instance];
          }
        },
        1000 * 60 * time,
@ -64,6 +76,13 @@ export class WAMonitoringService {
    }
  }

+  public clearDelInstanceTime(instance: string) {
+    if (this.delInstanceTimeouts[instance]) {
+      clearTimeout(this.delInstanceTimeouts[instance]);
+      delete this.delInstanceTimeouts[instance];
+    }
+  }
+
  public async instanceInfo(instanceNames?: string[]): Promise<any> {
    if (instanceNames && instanceNames.length > 0) {
      const inexistentInstances = instanceNames ? instanceNames.filter((instance) => !this.waInstances[instance]) : [];
@ -271,9 +290,19 @@ export class WAMonitoringService {
      token: instanceData.token,
      number: instanceData.number,
      businessId: instanceData.businessId,
+      ownerJid: instanceData.ownerJid,
    });

-    await instance.connectToWhatsapp();
+    if (instanceData.connectionStatus === 'open' || instanceData.connectionStatus === 'connecting') {
+      this.logger.info(
+        `Auto-connecting instance "${instanceData.instanceName}" (status: ${instanceData.connectionStatus})`,
+      );
+      await instance.connectToWhatsapp();
+    } else {
+      this.logger.info(
+        `Skipping auto-connect for instance "${instanceData.instanceName}" (status: ${instanceData.connectionStatus || 'close'})`,
+      );
+    }

    this.waInstances[instanceData.instanceName] = instance;
  }
@ -299,6 +328,7 @@ export class WAMonitoringService {
            token: instanceData.token,
            number: instanceData.number,
            businessId: instanceData.businessId,
+            connectionStatus: instanceData.connectionStatus as any, // Pass connection status
          };

          this.setInstance(instance);
@ -327,6 +357,8 @@ export class WAMonitoringService {
          token: instance.token,
          number: instance.number,
          businessId: instance.businessId,
+          ownerJid: instance.ownerJid,
+          connectionStatus: instance.connectionStatus as any, // Pass connection status
        });
      }),
    );
@ -351,6 +383,7 @@ export class WAMonitoringService {
          integration: instance.integration,
          token: instance.token,
          businessId: instance.businessId,
+          connectionStatus: instance.connectionStatus as any, // Pass connection status
        });
      }),
    );
@ -361,6 +394,8 @@ export class WAMonitoringService {
      try {
        await this.waInstances[instanceName]?.sendDataWebhook(Events.REMOVE_INSTANCE, null);

+        this.clearDelInstanceTime(instanceName);
+
        this.cleaningUp(instanceName);
        this.cleaningStoreData(instanceName);
      } finally {
@ -377,6 +412,8 @@ export class WAMonitoringService {
      try {
        await this.waInstances[instanceName]?.sendDataWebhook(Events.LOGOUT_INSTANCE, null);

+        this.clearDelInstanceTime(instanceName);
+
        if (this.configService.get<Chatwoot>('CHATWOOT').ENABLED) {
          this.waInstances[instanceName]?.clearCacheChatwoot();
        }
--- a/src/api/services/template.service.ts
+++ b/src/api/services/template.service.ts
@ -88,6 +88,77 @@ export class TemplateService {
    }
  }

+  public async edit(
+    instance: InstanceDto,
+    data: { templateId: string; category?: string; components?: any; allowCategoryChange?: boolean; ttl?: number },
+  ) {
+    const getInstance = await this.waMonitor.waInstances[instance.instanceName].instance;
+    if (!getInstance) {
+      throw new Error('Instance not found');
+    }
+
+    this.businessId = getInstance.businessId;
+    this.token = getInstance.token;
+
+    const payload: Record<string, unknown> = {};
+    if (typeof data.category === 'string') payload.category = data.category;
+    if (typeof data.allowCategoryChange === 'boolean') payload.allow_category_change = data.allowCategoryChange;
+    if (typeof data.ttl === 'number') payload.time_to_live = data.ttl;
+    if (data.components) payload.components = data.components;
+
+    const response = await this.requestEditTemplate(data.templateId, payload);
+
+    if (!response || response.error) {
+      if (response && response.error) {
+        const metaError = new Error(response.error.message || 'WhatsApp API Error');
+        (metaError as any).template = response.error;
+        throw metaError;
+      }
+      throw new Error('Error to edit template');
+    }
+
+    return response;
+  }
+
+  public async delete(instance: InstanceDto, data: { name: string; hsmId?: string }) {
+    const getInstance = await this.waMonitor.waInstances[instance.instanceName].instance;
+    if (!getInstance) {
+      throw new Error('Instance not found');
+    }
+
+    this.businessId = getInstance.businessId;
+    this.token = getInstance.token;
+
+    const response = await this.requestDeleteTemplate({ name: data.name, hsm_id: data.hsmId });
+
+    if (!response || response.error) {
+      if (response && response.error) {
+        const metaError = new Error(response.error.message || 'WhatsApp API Error');
+        (metaError as any).template = response.error;
+        throw metaError;
+      }
+      throw new Error('Error to delete template');
+    }
+
+    try {
+      // Best-effort local cleanup of stored template metadata
+      await this.prismaRepository.template.deleteMany({
+        where: {
+          OR: [
+            { name: data.name, instanceId: getInstance.id },
+            data.hsmId ? { templateId: data.hsmId, instanceId: getInstance.id } : undefined,
+          ].filter(Boolean) as any,
+        },
+      });
+    } catch (err) {
+      this.logger.warn(
+        `Failed to cleanup local template records after delete: ${(err as Error)?.message || String(err)}`,
+      );
+    }
+
+    return response;
+  }
+
  private async requestTemplate(data: any, method: string) {
    try {
      let urlServer = this.configService.get<WaBusiness>('WA_BUSINESS').URL;
@ -116,4 +187,38 @@ export class TemplateService {
      throw new Error(`Connection error: ${e.message}`);
    }
  }
+
+  private async requestEditTemplate(templateId: string, data: any) {
+    try {
+      let urlServer = this.configService.get<WaBusiness>('WA_BUSINESS').URL;
+      const version = this.configService.get<WaBusiness>('WA_BUSINESS').VERSION;
+      urlServer = `${urlServer}/${version}/${templateId}`;
+      const headers = { 'Content-Type': 'application/json', Authorization: `Bearer ${this.token}` };
+      const result = await axios.post(urlServer, data, { headers });
+      return result.data;
+    } catch (e) {
+      this.logger.error(
+        'WhatsApp API request error: ' + (e.response?.data ? JSON.stringify(e.response?.data) : e.message),
+      );
+      if (e.response?.data) return e.response.data;
+      throw new Error(`Connection error: ${e.message}`);
+    }
+  }
+
+  private async requestDeleteTemplate(params: { name: string; hsm_id?: string }) {
+    try {
+      let urlServer = this.configService.get<WaBusiness>('WA_BUSINESS').URL;
+      const version = this.configService.get<WaBusiness>('WA_BUSINESS').VERSION;
+      urlServer = `${urlServer}/${version}/${this.businessId}/message_templates`;
+      const headers = { Authorization: `Bearer ${this.token}` };
+      const result = await axios.delete(urlServer, { headers, params });
+      return result.data;
+    } catch (e) {
+      this.logger.error(
+        'WhatsApp API request error: ' + (e.response?.data ? JSON.stringify(e.response?.data) : e.message),
+      );
+      if (e.response?.data) return e.response.data;
+      throw new Error(`Connection error: ${e.message}`);
+    }
+  }
 }
--- a/src/api/types/wa.types.ts
+++ b/src/api/types/wa.types.ts
@ -52,6 +52,7 @@ export declare namespace wa {
    pairingCode?: string;
    authState?: { state: AuthenticationState; saveCreds: () => void };
    name?: string;
+    ownerJid?: string;
    wuid?: string;
    profileName?: string;
    profilePictureUrl?: string;
--- a/src/main.ts
+++ b/src/main.ts
@ -26,8 +26,8 @@ import cors from 'cors';
 import express, { json, NextFunction, Request, Response, urlencoded } from 'express';
 import { join } from 'path';

-function initWA() {
-  waMonitor.loadInstance();
+async function initWA() {
+  await waMonitor.loadInstance();
 }

 async function bootstrap() {
@ -159,7 +159,9 @@ async function bootstrap() {

  server.listen(httpServer.PORT, () => logger.log(httpServer.TYPE.toUpperCase() + ' - ON: ' + httpServer.PORT));

-  initWA();
+  initWA().catch((error) => {
+    logger.error('Error loading instances: ' + error);
+  });

  onUnexpectedError();
 }
--- a/src/utils/onWhatsappCache.ts
+++ b/src/utils/onWhatsappCache.ts
@ -65,78 +65,118 @@ interface ISaveOnWhatsappCacheParams {
  lid?: 'lid' | undefined;
 }

+function normalizeJid(jid: string | null | undefined): string | null {
+  if (!jid) return null;
+  return jid.startsWith('+') ? jid.slice(1) : jid;
+}
+
 export async function saveOnWhatsappCache(data: ISaveOnWhatsappCacheParams[]) {
-  if (configService.get<Database>('DATABASE').SAVE_DATA.IS_ON_WHATSAPP) {
-    for (const item of data) {
-      const remoteJid = item.remoteJid.startsWith('+') ? item.remoteJid.slice(1) : item.remoteJid;
+  if (!configService.get<Database>('DATABASE').SAVE_DATA.IS_ON_WHATSAPP) {
+    return;
+  }

-      // TODO: Buscar registro existente PRIMEIRO para preservar dados
-      const allJids = [remoteJid];
-
-      const altJid =
-        item.remoteJidAlt && item.remoteJidAlt.includes('@lid')
-          ? item.remoteJidAlt.startsWith('+')
-            ? item.remoteJidAlt.slice(1)
-            : item.remoteJidAlt
-          : null;
-
-      if (altJid) {
-        allJids.push(altJid);
+  // Processa todos os itens em paralelo para melhor performance
+  const processingPromises = data.map(async (item) => {
+    try {
+      const remoteJid = normalizeJid(item.remoteJid);
+      if (!remoteJid) {
+        logger.warn('[saveOnWhatsappCache] Item skipped, missing remoteJid.');
+        return;
      }

-      const expandedJids = allJids.flatMap((jid) => getAvailableNumbers(jid));
+      const altJidNormalized = normalizeJid(item.remoteJidAlt);
+      const lidAltJid = altJidNormalized && altJidNormalized.includes('@lid') ? altJidNormalized : null;

+      const baseJids = [remoteJid]; // Garante que o remoteJid esteja na lista inicial
+      if (lidAltJid) {
+        baseJids.push(lidAltJid);
+      }
+
+      const expandedJids = baseJids.flatMap((jid) => getAvailableNumbers(jid));
+
+      // 1. Busca entrada por jidOptions e também remoteJid
+      // Às vezes acontece do remoteJid atual NÃO ESTAR no jidOptions ainda, ocasionando o erro:
+      // 'Unique constraint failed on the fields: (`remoteJid`)'
+      // Isso acontece principalmente em grupos que possuem o número do criador no ID (ex.: '559911223345-1234567890@g.us')
      const existingRecord = await prismaRepository.isOnWhatsapp.findFirst({
        where: {
-          OR: expandedJids.map((jid) => ({ jidOptions: { contains: jid } })),
+          OR: [
+            ...expandedJids.map((jid) => ({ jidOptions: { contains: jid } })),
+            { remoteJid: remoteJid }, // TODO: Descobrir o motivo que causa o remoteJid não estar (às vezes) incluso na lista de jidOptions
+          ],
        },
      });

-      logger.verbose(`Register exists: ${existingRecord ? existingRecord.remoteJid : 'não not found'}`);
-
-      const finalJidOptions = [...expandedJids];
-
-      if (existingRecord?.jidOptions) {
-        const existingJids = existingRecord.jidOptions.split(',');
-        // TODO: Adicionar JIDs existentes que não estão na lista atual
-        existingJids.forEach((jid) => {
-          if (!finalJidOptions.includes(jid)) {
-            finalJidOptions.push(jid);
-          }
-        });
-      }
-
-      // TODO: Se tiver remoteJidAlt com @lid novo, adicionar
-      if (altJid && !finalJidOptions.includes(altJid)) {
-        finalJidOptions.push(altJid);
-      }
-
-      const uniqueNumbers = Array.from(new Set(finalJidOptions));
-
      logger.verbose(
-        `Saving: remoteJid=${remoteJid}, jidOptions=${uniqueNumbers.join(',')}, lid=${item.lid === 'lid' || item.remoteJid?.includes('@lid') ? 'lid' : null}`,
+        `[saveOnWhatsappCache] Register exists for [${expandedJids.join(',')}]? => ${existingRecord ? existingRecord.remoteJid : 'Not found'}`,
      );

+      // 2. Unifica todos os JIDs usando um Set para garantir valores únicos
+      const finalJidOptions = new Set(expandedJids);
+
+      if (lidAltJid) {
+        finalJidOptions.add(lidAltJid);
+      }
+
+      if (existingRecord?.jidOptions) {
+        existingRecord.jidOptions.split(',').forEach((jid) => finalJidOptions.add(jid));
+      }
+
+      // 3. Prepara o payload final
+      // Ordena os JIDs para garantir consistência na string final
+      const sortedJidOptions = [...finalJidOptions].sort();
+      const newJidOptionsString = sortedJidOptions.join(',');
+      const newLid = item.lid === 'lid' || item.remoteJid?.includes('@lid') ? 'lid' : null;
+
+      const dataPayload = {
+        remoteJid: remoteJid,
+        jidOptions: newJidOptionsString,
+        lid: newLid,
+      };
+
+      // 4. Decide entre Criar ou Atualizar
      if (existingRecord) {
+        // Compara a string de JIDs ordenada existente com a nova
+        const existingJidOptionsString = existingRecord.jidOptions
+          ? existingRecord.jidOptions.split(',').sort().join(',')
+          : '';
+
+        const isDataSame =
+          existingRecord.remoteJid === dataPayload.remoteJid &&
+          existingJidOptionsString === dataPayload.jidOptions &&
+          existingRecord.lid === dataPayload.lid;
+
+        if (isDataSame) {
+          logger.verbose(`[saveOnWhatsappCache] Data for ${remoteJid} is already up-to-date. Skipping update.`);
+          return; // Pula para o próximo item
+        }
+
+        // Os dados são diferentes, então atualiza
+        logger.verbose(
+          `[saveOnWhatsappCache] Register exists, updating: remoteJid=${remoteJid}, jidOptions=${dataPayload.jidOptions}, lid=${dataPayload.lid}`,
+        );
        await prismaRepository.isOnWhatsapp.update({
          where: { id: existingRecord.id },
-          data: {
-            remoteJid: remoteJid,
-            jidOptions: uniqueNumbers.join(','),
-            lid: item.lid === 'lid' || item.remoteJid?.includes('@lid') ? 'lid' : null,
-          },
+          data: dataPayload,
        });
      } else {
+        // Cria nova entrada
+        logger.verbose(
+          `[saveOnWhatsappCache] Register does not exist, creating: remoteJid=${remoteJid}, jidOptions=${dataPayload.jidOptions}, lid=${dataPayload.lid}`,
+        );
        await prismaRepository.isOnWhatsapp.create({
-          data: {
-            remoteJid: remoteJid,
-            jidOptions: uniqueNumbers.join(','),
-            lid: item.lid === 'lid' || item.remoteJid?.includes('@lid') ? 'lid' : null,
-          },
+          data: dataPayload,
        });
      }
+    } catch (e) {
+      // Loga o erro mas não para a execução dos outros promises
+      logger.error(`[saveOnWhatsappCache] Error processing item for ${item.remoteJid}: `);
+      logger.error(e);
    }
-  }
+  });
+
+  // Espera todas as operações paralelas terminarem
+  await Promise.allSettled(processingPromises);
 }

 export async function getOnWhatsappCache(remoteJids: string[]) {
--- a/src/utils/use-multi-file-auth-state-prisma.ts
+++ b/src/utils/use-multi-file-auth-state-prisma.ts
@ -1,6 +1,7 @@
 import { prismaRepository } from '@api/server.module';
 import { CacheService } from '@api/services/cache.service';
 import { CacheConf, configService } from '@config/env.config';
+import { Logger } from '@config/logger.config';
 import { INSTANCE_DIR } from '@config/path.config';
 import { AuthenticationState, BufferJSON, initAuthCreds, WAProto as proto } from 'baileys';
 import fs from 'fs/promises';
@ -73,12 +74,15 @@ async function fileExists(file: string): Promise<any> {
  }
 }

+const logger = new Logger('useMultiFileAuthStatePrisma');
+
 export default async function useMultiFileAuthStatePrisma(
  sessionId: string,
  cache: CacheService,
 ): Promise<{
  state: AuthenticationState;
  saveCreds: () => Promise<void>;
+  removeCreds: () => Promise<void>;
 }> {
  const localFolder = path.join(INSTANCE_DIR, sessionId);
  const localFile = (key: string) => path.join(localFolder, fixFileName(key) + '.json');
@ -142,6 +146,26 @@ export default async function useMultiFileAuthStatePrisma(
    }
  }

+  async function removeCreds(): Promise<any> {
+    const cacheConfig = configService.get<CacheConf>('CACHE');
+
+    // Redis
+    try {
+      if (cacheConfig.REDIS.ENABLED) {
+        await cache.delete(sessionId);
+        logger.info({ action: 'redis.delete', sessionId });
+
+        return;
+      }
+    } catch (err) {
+      logger.warn({ action: 'redis.delete', sessionId, err });
+    }
+
+    logger.info({ action: 'auth.key.delete', sessionId });
+
+    await deleteAuthKey(sessionId);
+  }
+
  let creds = await readData('creds');
  if (!creds) {
    creds = initAuthCreds();
@ -183,5 +207,7 @@ export default async function useMultiFileAuthStatePrisma(
    saveCreds: () => {
      return writeData(creds, 'creds');
    },
+
+    removeCreds,
  };
 }
--- a/src/utils/use-multi-file-auth-state-provider-files.ts
+++ b/src/utils/use-multi-file-auth-state-provider-files.ts
@ -39,7 +39,11 @@ import { Logger } from '@config/logger.config';
 import { AuthenticationCreds, AuthenticationState, BufferJSON, initAuthCreds, proto, SignalDataTypeMap } from 'baileys';
 import { isNotEmpty } from 'class-validator';

-export type AuthState = { state: AuthenticationState; saveCreds: () => Promise<void> };
+export type AuthState = {
+  state: AuthenticationState;
+  saveCreds: () => Promise<void>;
+  removeCreds: () => Promise<void>;
+};

 export class AuthStateProvider {
  constructor(private readonly providerFiles: ProviderFiles) {}
@ -86,6 +90,18 @@ export class AuthStateProvider {
      return response;
    };

+    const removeCreds = async () => {
+      const [response, error] = await this.providerFiles.removeSession(instance);
+      if (error) {
+        // this.logger.error(['removeData', error?.message, error?.stack]);
+        return;
+      }
+
+      logger.info({ action: 'remove.session', instance, response });
+
+      return;
+    };
+
    const creds: AuthenticationCreds = (await readData('creds')) || initAuthCreds();

    return {
@ -126,6 +142,10 @@ export class AuthStateProvider {
      saveCreds: async () => {
        return await writeData(creds, 'creds');
      },
+
+      removeCreds,
    };
  }
 }
+
+const logger = new Logger('useMultiFileAuthStatePrisma');
--- a/src/utils/use-multi-file-auth-state-redis-db.ts
+++ b/src/utils/use-multi-file-auth-state-redis-db.ts
@ -8,6 +8,7 @@ export async function useMultiFileAuthStateRedisDb(
 ): Promise<{
  state: AuthenticationState;
  saveCreds: () => Promise<void>;
+  removeCreds: () => Promise<void>;
 }> {
  const logger = new Logger('useMultiFileAuthStateRedisDb');

@ -36,6 +37,16 @@ export async function useMultiFileAuthStateRedisDb(
    }
  };

+  async function removeCreds(): Promise<any> {
+    try {
+      logger.warn({ action: 'redis.delete', instanceName });
+
+      return await cache.delete(instanceName);
+    } catch {
+      return;
+    }
+  }
+
  const creds: AuthenticationCreds = (await readData('creds')) || initAuthCreds();

  return {
@ -76,5 +87,7 @@ export async function useMultiFileAuthStateRedisDb(
    saveCreds: async () => {
      return await writeData(creds, 'creds');
    },
+
+    removeCreds,
  };
 }
--- a/src/validate/chat.schema.ts
+++ b/src/validate/chat.schema.ts
@ -195,8 +195,9 @@ export const contactValidateSchema: JSONSchema7 = {
        _id: { type: 'string', minLength: 1 },
        pushName: { type: 'string', minLength: 1 },
        id: { type: 'string', minLength: 1 },
+        remoteJid: { type: 'string', minLength: 1 },
      },
-      ...isNotEmpty('_id', 'id', 'pushName'),
+      ...isNotEmpty('_id', 'id', 'pushName', 'remoteJid'),
    },
  },
 };
--- a/src/validate/templateDelete.schema.ts
+++ b/src/validate/templateDelete.schema.ts
@ -0,0 +1,32 @@
+import { JSONSchema7 } from 'json-schema';
+import { v4 } from 'uuid';
+
+const isNotEmpty = (...propertyNames: string[]): JSONSchema7 => {
+  const properties: Record<string, unknown> = {};
+  propertyNames.forEach(
+    (property) =>
+      (properties[property] = {
+        minLength: 1,
+        description: `The "${property}" cannot be empty`,
+      }),
+  );
+  return {
+    if: {
+      propertyNames: {
+        enum: [...propertyNames],
+      },
+    },
+    then: { properties },
+  } as JSONSchema7;
+};
+
+export const templateDeleteSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    hsmId: { type: 'string' },
+  },
+  required: ['name'],
+  ...isNotEmpty('name'),
+};
--- a/src/validate/templateEdit.schema.ts
+++ b/src/validate/templateEdit.schema.ts
@ -0,0 +1,35 @@
+import { JSONSchema7 } from 'json-schema';
+import { v4 } from 'uuid';
+
+const isNotEmpty = (...propertyNames: string[]): JSONSchema7 => {
+  const properties: Record<string, unknown> = {};
+  propertyNames.forEach(
+    (property) =>
+      (properties[property] = {
+        minLength: 1,
+        description: `The "${property}" cannot be empty`,
+      }),
+  );
+  return {
+    if: {
+      propertyNames: {
+        enum: [...propertyNames],
+      },
+    },
+    then: { properties },
+  } as JSONSchema7;
+};
+
+export const templateEditSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    templateId: { type: 'string' },
+    category: { type: 'string', enum: ['AUTHENTICATION', 'MARKETING', 'UTILITY'] },
+    allowCategoryChange: { type: 'boolean' },
+    ttl: { type: 'number' },
+    components: { type: 'array' },
+  },
+  required: ['templateId'],
+  ...isNotEmpty('templateId'),
+};
--- a/src/validate/validate.schema.ts
+++ b/src/validate/validate.schema.ts
@ -8,5 +8,7 @@ export * from './message.schema';
 export * from './proxy.schema';
 export * from './settings.schema';
 export * from './template.schema';
+export * from './templateDelete.schema';
+export * from './templateEdit.schema';
 export * from '@api/integrations/chatbot/chatbot.schema';
 export * from '@api/integrations/event/event.schema';