Merge branch 'release/1.6.1'

fix: when deleting a message in whatsapp, delete the message in chatwoot too

.github/ISSUE_TEMPLATE/-en--bug-report.md

@@ -0,0 +1,38 @@
+---
+name: "[EN] Bug report"
+about: Create a report to help us improve
+title: "[EN][BUG]"
+labels: bug
+assignees: ''
+
+---
+
+### Title: [Brief Description of the Bug]
+
+#### Description:
+Describe in detail the problem you encountered. Include any relevant context that may help understand the origin of the bug.
+
+#### Steps to Reproduce:
+1. List the steps necessary to reproduce the problem.
+2. Try to be as specific as possible.
+3. If the problem occurs in a specific scenario, describe it here.
+
+#### Expected Behavior:
+Describe what you expected to happen when following the steps above.
+
+#### Current Behavior:
+Explain what actually happens when you follow the steps above.
+
+#### Screenshots/Videos:
+If possible, add screenshots or videos illustrating the problem. This can be extremely helpful in understanding the issue.
+
+#### Environment:
+- **Server:** [e.g., Ubuntu 18.04]
+- **API Version:** [e.g., 1.5.4]
+- **Other Hardware/Software Specifications:** [e.g., CPU, GPU]
+
+#### Submitting Logs:
+Please attach logs that may be related to the problem. If the logs contain sensitive information, consider sending them privately to one of the project maintainers.
+
+#### Additional Notes:
+Include here any other information that you think might be useful in understanding or resolving the bug.

.github/ISSUE_TEMPLATE/-en--feature-request.md

@@ -0,0 +1,28 @@
+---
+name: "[EN] Feature request"
+about: Suggest an idea for the API
+title: "[EN][FEAT]"
+labels: enhancement
+assignees: ''
+
+---
+
+### Title: [Brief Description of Feature Request]
+
+#### Detailed Description:
+Clearly and in detail, describe the functionality you wish to be implemented. Explain how this fits into the context of the project.
+
+#### Rationale:
+Explain why this functionality would be useful for the project. This helps in understanding the importance and priority of the request.
+
+#### Usage Examples:
+Provide specific examples of how this feature could be used. This can include scenarios or use cases where the feature would be particularly beneficial.
+
+#### Possible Implementations:
+If you have ideas on how this feature might be implemented, please share them here. This is not mandatory but can be helpful for the development team.
+
+#### Impact on the Project:
+Discuss how this new feature could impact other parts of the project, if applicable.
+
+#### Additional Notes:
+Any other information you believe is relevant to your request.

.github/ISSUE_TEMPLATE/-pt--reportar-bug.md

@@ -0,0 +1,38 @@
+---
+name: "[PT] Reportar bug"
+about: Reportar um problema
+title: "[PT][BUG]"
+labels: bug
+assignees: ''
+
+---
+
+### Título: [Breve Descrição do Bug]
+
+#### Descrição:
+Descreva detalhadamente o problema que você encontrou. Inclua qualquer contexto relevante que possa ajudar a entender a origem do bug.
+
+#### Passos para Reproduzir:
+1. Liste os passos necessários para reproduzir o problema.
+2. Tente ser o mais específico possível.
+3. Se o problema ocorrer em um cenário específico, descreva-o aqui.
+
+#### Comportamento Esperado:
+Descreva o que você esperava que acontecesse quando seguisse os passos acima.
+
+#### Comportamento Atual:
+Explique o que realmente acontece quando você segue os passos acima.
+
+#### Capturas de Tela/Vídeos:
+Se possível, adicione capturas de tela ou vídeos que ilustrem o problema. Isso pode ser extremamente útil para entender o problema.
+
+#### Ambiente:
+- **Servidor:** [ex: Ubuntu 18.04]
+- **Versão da API:** [ex: 1.5.4]
+- **Outras Especificações de Hardware/Software:** [ex: CPU, GPU]
+
+#### Envio de Logs:
+Por favor, anexe os logs que possam estar relacionados ao problema. Se os logs contiverem informações sensíveis, considere enviá-los de forma privada para um dos mantenedores do projeto.
+
+#### Notas Adicionais:
+Inclua aqui qualquer outra informação que você ache que possa ser útil para entender ou resolver o bug.

.github/ISSUE_TEMPLATE/-pt--solicitar-recurso.md

@@ -0,0 +1,28 @@
+---
+name: "[PT] Solicitar recurso"
+about: Sugira novos recursos para a API
+title: "[PT][FEAT]"
+labels: enhancement
+assignees: ''
+
+---
+
+### Título: [Breve Descrição da Solicitação de Recurso]
+
+#### Descrição Detalhada:
+Descreva claramente e em detalhes a funcionalidade que você deseja que seja implementada. Explique como isso se encaixa no contexto do projeto.
+
+#### Racional:
+Explique por que essa funcionalidade seria útil para o projeto. Isso ajuda a entender a importância e a prioridade da solicitação.
+
+#### Exemplos de Uso:
+Forneça exemplos específicos de como essa funcionalidade poderia ser utilizada. Isso pode incluir cenários ou casos de uso onde a funcionalidade seria particularmente benéfica.
+
+#### Possíveis Implementações:
+Se você tem ideias sobre como essa funcionalidade pode ser implementada, por favor, compartilhe-as aqui. Isso não é obrigatório, mas pode ser útil para a equipe de desenvolvimento.
+
+#### Impacto no Projeto:
+Discuta como essa nova funcionalidade poderia impactar outras partes do projeto, se aplicável.
+
+#### Notas Adicionais:
+Qualquer outra informação que você acredita ser relevante para a sua solicitação.

.gitignore

@@ -39,6 +39,7 @@ docker-compose.yaml
 /test/
 /src/env.yml
 /store
+*.env
 
 /temp/*
 

.vscode/settings.json

@@ -5,7 +5,9 @@
   "editor.smoothScrolling": true,
   "editor.tabSize": 2,
   "editor.codeActionsOnSave": {
-     "source.fixAll.eslint": true,
-     "source.fixAll": true
-  }
+    "source.fixAll.eslint": "explicit",
+    "source.fixAll": "explicit"
+  },
+  "prisma-smart-formatter.typescript.defaultFormatter": "esbenp.prettier-vscode",
+  "prisma-smart-formatter.prisma.defaultFormatter": "Prisma.prisma"
 }

CHANGELOG.md

@@ -1,3 +1,108 @@
+# 1.6.1 (2023-12-22 11:43)
+
+### Fixed
+
+* Fixed Lid Messages
+* Fixed sending variables to typebot
+* Fixed sending variables from typebot
+* Correction sending s3/minio media to chatwoot and typebot
+* Fixed the problem with typebot closing at the end of the flow, now this is optional with the TYPEBOT_KEEP_OPEN variable
+* Fixed chatwoot Bold, Italic and Underline formatting using Regex
+* Added the sign_delimiter property to the Chatwoot configuration, allowing you to set a different delimiter for the signature. Default when not defined \n
+* Include instance Id field in the instance configuration
+* Fixed the pairing code
+* Adjusts in typebot
+* Fix the problem when disconnecting the instance and connecting again using mongodb
+* Options to disable docs and manager
+* When deleting a message in whatsapp, delete the message in chatwoot too
+
+
+# 1.6.0 (2023-12-12 17:24)
+
+### Feature
+
+* Added AWS SQS Integration
+* Added support for new typebot API
+* Added endpoint sendPresence
+* New Instance Manager
+* Added auto_create to the chatwoot set to create the inbox automatically or not
+* Added reply, delete and message reaction in chatwoot v3.3.1
+
+### Fixed
+
+* Adjusts in proxy
+* Adjusts in start session for Typebot
+* Added mimetype field when sending media
+* Ajusts in validations to messages.upsert
+* Fixed messages not received: error handling when updating contact in chatwoot
+* Fix workaround to manage param data as an array in mongodb
+* Removed await from webhook when sending a message
+* Update typebot.service.ts - element.underline change ~ for *
+* Removed api restart on receiving an error
+* Fixes in mongodb and chatwoot
+* Adjusted return from queries in mongodb
+* Added restart instance when update profile picture
+* Correction of chatwoot functioning with admin flows
+* Fixed problem that did not generate qrcode with the chatwoot_conversation_pending option enabled
+* Fixed issue where CSAT opened a new ticket when reopen_conversation was disabled
+* Fixed issue sending contact to Chatwoot via iOS
+
+### Integrations
+
+* Chatwoot: v3.3.1
+* Typebot: v2.20.0
+
+# 1.5.4 (2023-10-09 20:43)
+
+### Fixed
+
+* Baileys logger typing issue resolved
+* Solved problem with duplicate messages in chatwoot
+
+# 1.5.3 (2023-10-06 18:55)
+
+### Feature
+
+* Swagger documentation
+* Added base 64 sending option via webhook
+
+### Fixed
+
+* Remove rabbitmq queues when delete instances
+* Improvement in restart instance to completely redo the connection
+* Update node version: v20
+* Correction of messages sent by the api and typebot not appearing in chatwoot
+* Adjustment to start typebot, added startSession parameter
+* Chatwoot now receives messages sent via api and typebot
+* Fixed problem with starting with an input in typebot
+* Added check to ensure variables are not empty before executing foreach in start typebot
+
+# 1.5.2 (2023-09-28 17:56)
+
+### Fixed
+
+* Fix chatwootSchema in chatwoot model to store reopen_conversation and conversation_pending options
+* Problem resolved when sending files from minio to typebot
+* Improvement in the "startTypebot" method to create persistent session when triggered
+* New manager for Evo 1.5.2 - Set Typebot update
+* Resolved problems when reading/querying instances
+
+# 1.5.1 (2023-09-17 13:50)
+
+### Feature
+
+* Added listening_from_me option in Set Typebot
+* Added variables options in Start Typebot
+* Added webhooks for typebot events
+* Added ChamaAI integration
+* Added webhook to send errors
+* Added support for messaging with ads on chatwoot
+
+### Fixed
+
+* Fix looping connection messages in chatwoot
+* Improved performance of fetch instances
+
 # 1.5.0 (2023-08-18 12:47)
 
 ### Feature
@@ -24,9 +129,9 @@
 
 ### Integrations
 
-- Chatwoot: v2.18.0 - v3.0.0
-- Typebot: v2.16.0
-- Manager Evolution API
+* Chatwoot: v2.18.0 - v3.0.0
+* Typebot: v2.16.0
+* Manager Evolution API
 
 # 1.4.8 (2023-07-27 10:27)
 
@@ -79,7 +184,7 @@
 
 ### Fixed
 
-* Fixed validation is set settings 
+* Fixed validation is set settings
 * Adjusts in group validations
 * Ajusts in sticker message to chatwoot
 
@@ -114,7 +219,7 @@
 
 ### Integrations
 
-- Chatwoot: v2.18.0 - v3.0.0 (Beta)
+* Chatwoot: v2.18.0 - v3.0.0 (Beta)
 
 # 1.3.2 (2023-07-21 17:19)
 
@@ -130,7 +235,7 @@
 
 ### Integrations
 
-- Chatwoot: v2.18.0
+* Chatwoot: v2.18.0
 
 # 1.3.1 (2023-07-20 07:48)
 
@@ -140,7 +245,7 @@
 
 ### Integrations
 
-- Chatwoot: v2.18.0
+* Chatwoot: v2.18.0
 
 # 1.3.0 (2023-07-19 11:33)
 
@@ -156,7 +261,7 @@
 * Translation set to default (english) in chatwoot
 
 ### Fixed
- 
+
 * Fixed error to send message in large groups
 * Docker files adjusted
 * Fixed in the postman collection the webhookByEvent parameter by webhook_by_events
@@ -177,7 +282,7 @@
 
 ### Integrations
 
-- Chatwoot: v2.18.0
+* Chatwoot: v2.18.0
 
 # 1.2.2 (2023-07-15 09:36)
 
@@ -188,7 +293,7 @@
 
 ### Integrations
 
-- Chatwoot: v2.18.0
+* Chatwoot: v2.18.0
 
 # 1.2.1 (2023-07-14 19:04)
 
@@ -344,4 +449,4 @@
 * Sending the local webhook url as destination in the webhook data for webhook redirection
 * Startup modes, server or container
 * Server Mode works normally as everyone is used to
-* Container mode made to use one instance per container, when starting the application an instance is already created and the qrcode is generated and it starts sending webhook without having to call it manually, it only allows one instance at a time.
+* Container mode made to use one instance per container, when starting the application an instance is already created and the qrcode is generated and it starts sending webhook without having to call it manually, it only allows one instance at a time.

Docker/.env.example

@@ -51,6 +51,12 @@ RABBITMQ_URI=amqp://guest:guest@rabbitmq:5672
 
 WEBSOCKET_ENABLED=false
 
+SQS_ENABLED=false
+SQS_ACCESS_KEY_ID=
+SQS_SECRET_ACCESS_KEY=
+SQS_ACCOUNT_ID=
+SQS_REGION=
+
 # Global Webhook Settings
 # Each instance's Webhook URL and events will be requested at the time it is created
 ## Define a global webhook that will listen for enabled events from all instances
@@ -81,16 +87,28 @@ WEBHOOK_EVENTS_CONNECTION_UPDATE=true
 WEBHOOK_EVENTS_CALL=true
 # This event fires every time a new token is requested via the refresh route
 WEBHOOK_EVENTS_NEW_JWT_TOKEN=false
+# This events is used with Typebot
+WEBHOOK_EVENTS_TYPEBOT_START=false
+WEBHOOK_EVENTS_TYPEBOT_CHANGE_STATUS=false
+# This event is used with Chama AI
+WEBHOOK_EVENTS_CHAMA_AI_ACTION=false
+# This event is used to send errors
+WEBHOOK_EVENTS_ERRORS=false
+WEBHOOK_EVENTS_ERRORS_WEBHOOK=
 
 # Name that will be displayed on smartphone connection
 CONFIG_SESSION_PHONE_CLIENT=EvolutionAPI
-# Browser Name = chrome | firefox | edge | opera | safari
-CONFIG_SESSION_PHONE_NAME=chrome
+# Browser Name = Chrome | Firefox | Edge | Opera | Safari
+CONFIG_SESSION_PHONE_NAME=Chrome
 
 # Set qrcode display limit
 QRCODE_LIMIT=30
 QRCODE_COLOR=#198754
 
+# old | latest
+TYPEBOT_API_VERSION=latest
+TYPEBOT_KEEP_OPEN=false
+
 # Defines an authentication type for the api
 # We recommend using the apikey because it will allow you to use a custom token,
 # if you use jwt, a random token will be generated and may be expired and you will have to generate a new token

Docker/docker-compose.yaml

@@ -0,0 +1,22 @@
+version: '3.3'
+
+services:
+
+  api:
+    container_name: evolution_api
+    image: davidsongomes/evolution-api
+    restart: always
+    ports:
+      - 8080:8080
+    volumes:
+      - evolution_instances:/evolution/instances
+      - evolution_store:/evolution/store
+    env_file:
+      - .env
+    command: ['node', './dist/src/main.js']
+    expose:
+      - 8080
+
+volumes:
+  evolution_instances:
+  evolution_store:

Docker/evolution-api-all-services/.env.example

@@ -0,0 +1,109 @@
+# Server URL - Set your application url
+SERVER_URL='http://localhost:8080'
+
+# Cors - * for all or set separate by commas -  ex.: 'yourdomain1.com, yourdomain2.com'
+CORS_ORIGIN='*'
+CORS_METHODS='POST,GET,PUT,DELETE'
+CORS_CREDENTIALS=true
+
+# Determine the logs to be displayed
+LOG_LEVEL='ERROR,WARN,DEBUG,INFO,LOG,VERBOSE,DARK,WEBHOOKS'
+LOG_COLOR=true
+# Log Baileys - "fatal" | "error" | "warn" | "info" | "debug" | "trace"
+LOG_BAILEYS=error
+
+# Determine how long the instance should be deleted from memory in case of no connection.
+# Default time: 5 minutes
+# If you don't even want an expiration, enter the value false
+DEL_INSTANCE=false
+
+# Temporary data storage
+STORE_MESSAGES=true
+STORE_MESSAGE_UP=true
+STORE_CONTACTS=true
+STORE_CHATS=true
+
+# Set Store Interval in Seconds (7200 = 2h)
+CLEAN_STORE_CLEANING_INTERVAL=7200
+CLEAN_STORE_MESSAGES=true
+CLEAN_STORE_MESSAGE_UP=true
+CLEAN_STORE_CONTACTS=true
+CLEAN_STORE_CHATS=true
+
+# Permanent data storage
+DATABASE_ENABLED=true
+DATABASE_CONNECTION_URI=mongodb://root:root@mongodb:27017/?authSource=admin&readPreference=primary&ssl=false&directConnection=true
+DATABASE_CONNECTION_DB_PREFIX_NAME=evolution
+
+# Choose the data you want to save in the application's database or store
+DATABASE_SAVE_DATA_INSTANCE=false
+DATABASE_SAVE_DATA_NEW_MESSAGE=false
+DATABASE_SAVE_MESSAGE_UPDATE=false
+DATABASE_SAVE_DATA_CONTACTS=false
+DATABASE_SAVE_DATA_CHATS=false
+
+REDIS_ENABLED=true
+REDIS_URI=redis://redis:6379
+REDIS_PREFIX_KEY=evolution
+
+# Global Webhook Settings
+# Each instance's Webhook URL and events will be requested at the time it is created
+## Define a global webhook that will listen for enabled events from all instances
+WEBHOOK_GLOBAL_URL=''
+WEBHOOK_GLOBAL_ENABLED=false
+# With this option activated, you work with a url per webhook event, respecting the global url and the name of each event
+WEBHOOK_GLOBAL_WEBHOOK_BY_EVENTS=false
+## Set the events you want to hear  
+WEBHOOK_EVENTS_APPLICATION_STARTUP=false
+WEBHOOK_EVENTS_QRCODE_UPDATED=true
+WEBHOOK_EVENTS_MESSAGES_SET=true
+WEBHOOK_EVENTS_MESSAGES_UPSERT=true
+WEBHOOK_EVENTS_MESSAGES_UPDATE=true
+WEBHOOK_EVENTS_MESSAGES_DELETE=true
+WEBHOOK_EVENTS_SEND_MESSAGE=true
+WEBHOOK_EVENTS_CONTACTS_SET=true
+WEBHOOK_EVENTS_CONTACTS_UPSERT=true
+WEBHOOK_EVENTS_CONTACTS_UPDATE=true
+WEBHOOK_EVENTS_PRESENCE_UPDATE=true
+WEBHOOK_EVENTS_CHATS_SET=true
+WEBHOOK_EVENTS_CHATS_UPSERT=true
+WEBHOOK_EVENTS_CHATS_UPDATE=true
+WEBHOOK_EVENTS_CHATS_DELETE=true
+WEBHOOK_EVENTS_GROUPS_UPSERT=true
+WEBHOOK_EVENTS_GROUPS_UPDATE=true
+WEBHOOK_EVENTS_GROUP_PARTICIPANTS_UPDATE=true
+WEBHOOK_EVENTS_CONNECTION_UPDATE=true
+# This event fires every time a new token is requested via the refresh route
+WEBHOOK_EVENTS_NEW_JWT_TOKEN=false
+
+# Name that will be displayed on smartphone connection
+CONFIG_SESSION_PHONE_CLIENT='Evolution API'
+# Browser Name = chrome | firefox | edge | opera | safari
+CONFIG_SESSION_PHONE_NAME=chrome
+
+# Set qrcode display limit
+QRCODE_LIMIT=30
+
+# Defines an authentication type for the api
+# We recommend using the apikey because it will allow you to use a custom token,
+# if you use jwt, a random token will be generated and may be expired and you will have to generate a new token
+# jwt or 'apikey'
+AUTHENTICATION_TYPE='apikey'
+## Define a global apikey to access all instances.
+### OBS: This key must be inserted in the request header to create an instance.
+AUTHENTICATION_API_KEY='B6D711FCDE4D4FD5936544120E713976'
+AUTHENTICATION_EXPOSE_IN_FETCH_INSTANCES=true
+## Set the secret key to encrypt and decrypt your token and its expiration time
+# seconds - 3600s ===1h | zero (0) - never expires
+AUTHENTICATION_JWT_EXPIRIN_IN=0
+AUTHENTICATION_JWT_SECRET='L0YWtjb2w554WFqPG'
+# Set the instance name and webhook url to create an instance in init the application
+# With this option activated, you work with a url per webhook event, respecting the local url and the name of each event
+# container or server
+AUTHENTICATION_INSTANCE_MODE=server
+# if you are using container mode, set the container name and the webhook url to default instance
+AUTHENTICATION_INSTANCE_NAME=evolution
+AUTHENTICATION_INSTANCE_WEBHOOK_URL=''
+AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID=1
+AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN=123456
+AUTHENTICATION_INSTANCE_CHATWOOT_URL=''

Docker/evolution-api-all-services/docker-compose.yaml

@@ -0,0 +1,91 @@
+version: '3.3'
+
+services:
+
+  mongodb:
+    container_name: mongodb
+    image: mongo
+    restart: on-failure
+    ports:
+      - 27017:27017
+    environment:
+      - MONGO_INITDB_ROOT_USERNAME=root
+      - MONGO_INITDB_ROOT_PASSWORD=root
+      - PUID=1000
+      - PGID=1000
+    volumes:
+      - evolution_mongodb_data:/data/db
+      - evolution_mongodb_configdb:/data/configdb
+    expose:
+      - 27017
+
+  mongo-express:
+    container_name: mongodb-express
+    image: mongo-express
+    restart: on-failure
+    ports:
+      - 8081:8081
+    depends_on:
+      - mongodb
+    environment:
+      ME_CONFIG_BASICAUTH_USERNAME: root
+      ME_CONFIG_BASICAUTH_PASSWORD: root
+      ME_CONFIG_MONGODB_SERVER: mongodb
+      ME_CONFIG_MONGODB_ADMINUSERNAME: root
+      ME_CONFIG_MONGODB_ADMINPASSWORD: root
+    links:
+      - mongodb
+
+  redis:
+    container_name: redis
+    image: redis:latest
+    restart: on-failure
+    ports:
+      - 6379:6379
+    command: >
+      redis-server
+      --port 6379
+      --appendonly yes
+    volumes:
+      - evolution_redis:/data
+
+  rebrow:
+    container_name: rebrow
+    image: marian/rebrow
+    restart: on-failure
+    depends_on:
+      - redis
+    ports: 
+      - 5001:5001
+    links:
+      - redis
+
+  api:
+    container_name: evolution_api
+    image: davidsongomes/evolution-api
+    restart: always
+    depends_on:
+      - mongodb
+      - redis
+    ports:
+      - 8080:8080
+    volumes:
+      - evolution_instances:/evolution/instances
+      - evolution_store:/evolution/store
+    env_file:
+      - .env
+    command: ['node', './dist/src/main.js']
+    expose:
+      - 8080
+
+volumes:
+  evolution_mongodb_data:
+  evolution_mongodb_configdb:
+  evolution_redis:
+  evolution_instances:
+  evolution_store:
+
+networks:
+  evolution-net:
+    external: true
+  

Docker/mongodb/docker-compose.yaml

@@ -35,7 +35,8 @@ volumes:
   evolution_mongodb_data:
   evolution_mongodb_configdb:
 
+
 networks:
   evolution-net:
-    external: true
-    
+    name: evolution-net
+    driver: bridge

Docker/redis/docker-compose.yaml

@@ -5,17 +5,17 @@ services:
     image: redis:latest
     container_name: redis
     command: >
-      redis-server
-      --port 6379
-      --appendonly yes
+      redis-server --port 6379 --appendonly yes
     volumes:
       - evolution_redis:/data
     ports:
       - 6379:6379
-    
+
 volumes:
   evolution_redis:
 
+
 networks:
   evolution-net:
-    external: true
+    name: evolution-net
+    driver: bridge

Dockerfile

@@ -1,6 +1,6 @@
-FROM node:16.18-alpine
+FROM node:20.7.0-alpine AS builder
 
-LABEL version="1.5.0" description="Api to control whatsapp features through http requests." 
+LABEL version="1.6.1" description="Api to control whatsapp features through http requests." 
 LABEL maintainer="Davidson Gomes" git="https://github.com/DavidsonGomes"
 LABEL contact="contato@agenciadgcode.com"
 
@@ -11,9 +11,19 @@ WORKDIR /evolution
 
 COPY ./package.json .
 
+RUN npm install
+
+COPY . .
+
+RUN npm run build
+
+FROM node:20.7.0-alpine AS final
+
 ENV TZ=America/Sao_Paulo
 ENV DOCKER_ENV=true
 
+ENV SERVER_TYPE=http
+ENV SERVER_PORT=8080
 ENV SERVER_URL=http://localhost:8080
 
 ENV CORS_ORIGIN=*
@@ -56,12 +66,20 @@ ENV RABBITMQ_URI=amqp://guest:guest@rabbitmq:5672
 
 ENV WEBSOCKET_ENABLED=false
 
+ENV SQS_ENABLED=false
+ENV SQS_ACCESS_KEY_ID=
+ENV SQS_SECRET_ACCESS_KEY=
+ENV SQS_ACCOUNT_ID=
+ENV SQS_REGION=
+
 ENV WEBHOOK_GLOBAL_URL=
 ENV WEBHOOK_GLOBAL_ENABLED=false
 
 ENV WEBHOOK_GLOBAL_WEBHOOK_BY_EVENTS=false
 
 ENV WEBHOOK_EVENTS_APPLICATION_STARTUP=false
+ENV WEBHOOK_EVENTS_INSTANCE_CREATE=false
+ENV WEBHOOK_EVENTS_INSTANCE_DELETE=false
 ENV WEBHOOK_EVENTS_QRCODE_UPDATED=true
 ENV WEBHOOK_EVENTS_MESSAGES_SET=true
 ENV WEBHOOK_EVENTS_MESSAGES_UPSERT=true
@@ -84,12 +102,22 @@ ENV WEBHOOK_EVENTS_CALL=true
 
 ENV WEBHOOK_EVENTS_NEW_JWT_TOKEN=false
 
+ENV WEBHOOK_EVENTS_TYPEBOT_START=false
+ENV WEBHOOK_EVENTS_TYPEBOT_CHANGE_STATUS=false
+
+ENV WEBHOOK_EVENTS_CHAMA_AI_ACTION=false
+
+ENV WEBHOOK_EVENTS_ERRORS=false
+ENV WEBHOOK_EVENTS_ERRORS_WEBHOOK=
+
 ENV CONFIG_SESSION_PHONE_CLIENT=EvolutionAPI
-ENV CONFIG_SESSION_PHONE_NAME=chrome
+ENV CONFIG_SESSION_PHONE_NAME=Chrome
 
 ENV QRCODE_LIMIT=30
 ENV QRCODE_COLOR=#198754
 
+ENV TYPEBOT_API_VERSION=latest
+
 ENV AUTHENTICATION_TYPE=apikey
 
 ENV AUTHENTICATION_API_KEY=B6D711FCDE4D4FD5936544120E713976
@@ -106,10 +134,8 @@ ENV AUTHENTICATION_INSTANCE_CHATWOOT_ACCOUNT_ID=1
 ENV AUTHENTICATION_INSTANCE_CHATWOOT_TOKEN=123456
 ENV AUTHENTICATION_INSTANCE_CHATWOOT_URL=<url>
 
-RUN npm install
+WORKDIR /evolution
 
-COPY . .
-
-RUN npm run build
+COPY --from=builder /evolution .
 
 CMD [ "node", "./dist/src/main.js" ]

README.md

@@ -39,12 +39,13 @@ This code was produced based on the baileys library and it is still under develo
   </a>
 </div>
 
-#### Buy me coffe
+#### Buy me coffe - PIX
 
 <div align="center">
   <a href="https://bmc.link/evolutionapi" target="_blank" rel="noopener noreferrer">
-    <img src="./public/images/bmc_qr.png" style="width: 50% !important;">
+    <img src="./public/images/qrcode-pix.png" style="width: 50% !important;">
   </a>
+  <p><b>CHAVE PIX (Telefone):</b> (74)99987-9409</p>
 </div>
 
 </br>

docker-compose.yaml.example

@@ -4,6 +4,7 @@ services:
   api:
     container_name: evolution_api
     image: evolution/api:local
+    build: .
     restart: always
     ports:
       - 8080:8080
@@ -24,5 +25,5 @@ volumes:
 
 networks:
   evolution-net:
-    external: true
-  
+    name: evolution-net
+    driver: bridge

docker-compose.yaml.example.complete

@@ -4,6 +4,7 @@ services:
   api:
     container_name: evolution_api
     image: evolution/api:local
+    build: .
     restart: always
     ports:
       - 8080:8080
@@ -75,5 +76,5 @@ volumes:
 
 networks:
   evolution-net:
-    external: true
-  
+    name: evolution-net
+    driver: bridge

docker-compose.yaml.example.dockerhub

@@ -3,7 +3,7 @@ version: '3.3'
 services:
   api:
     container_name: evolution_api
-    image: davidsongomes/evolution-api:latest
+    image: atendai/evolution-api:latest
     restart: always
     ports:
       - 8080:8080
@@ -24,5 +24,5 @@ volumes:
 
 networks:
   evolution-net:
-    external: true
-  
+    name: evolution-net
+    driver: bridge

docker.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-
-NET='evolution-net'
-IMAGE='evolution/api:local'
-
-if !(docker network ls | grep ${NET} > /dev/null)
-then
-  docker network create -d bridge ${NET}
-fi
-
-docker build -t ${IMAGE} .
-
-docker compose up -d

package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolution-api",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "description": "Rest api for communication with WhatsApp",
   "main": "./dist/src/main.js",
   "scripts": {
@@ -43,11 +43,12 @@
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "@figuro/chatwoot-sdk": "^1.1.14",
+    "@figuro/chatwoot-sdk": "^1.1.16",
     "@hapi/boom": "^10.0.1",
     "@sentry/node": "^7.59.2",
-    "@whiskeysockets/baileys": "github:EvolutionAPI/Baileys",
+    "@whiskeysockets/baileys": "github:PurpShell/Baileys#combined",
     "amqplib": "^0.10.3",
+    "aws-sdk": "^2.1499.0",
     "axios": "^1.3.5",
     "class-validator": "^0.13.2",
     "compression": "^1.7.4",
@@ -55,6 +56,7 @@
     "cross-env": "^7.0.3",
     "dayjs": "^1.11.7",
     "eventemitter2": "^6.4.9",
+    "evolution-manager": "^0.4.11",
     "exiftool-vendored": "^22.0.0",
     "express": "^4.18.2",
     "express-async-errors": "^3.1.1",
@@ -69,6 +71,7 @@
     "mongoose": "^6.10.5",
     "node-cache": "^5.1.2",
     "node-mime-types": "^1.1.0",
+    "node-windows": "^1.0.0-beta.8",
     "pino": "^8.11.0",
     "proxy-agent": "^6.3.0",
     "qrcode": "^1.5.1",
@@ -76,7 +79,10 @@
     "redis": "^4.6.5",
     "sharp": "^0.30.7",
     "socket.io": "^4.7.1",
-    "uuid": "^9.0.0"
+    "socks-proxy-agent": "^8.0.1",
+    "swagger-ui-express": "^5.0.0",
+    "uuid": "^9.0.0",
+    "yamljs": "^0.3.0"
   },
   "devDependencies": {
     "@types/compression": "^1.7.2",
@@ -86,6 +92,7 @@
     "@types/jsonwebtoken": "^8.5.9",
     "@types/mime-types": "^2.1.1",
     "@types/node": "^18.15.11",
+    "@types/node-windows": "^0.1.2",
     "@types/qrcode": "^1.5.0",
     "@types/qrcode-terminal": "^0.12.0",
     "@types/uuid": "^8.3.4",

src/config/env.config.ts

@@ -3,7 +3,13 @@ import { readFileSync } from 'fs';
 import { load } from 'js-yaml';
 import { join } from 'path';
 
-export type HttpServer = { TYPE: 'http' | 'https'; PORT: number; URL: string };
+export type HttpServer = {
+  TYPE: 'http' | 'https';
+  PORT: number;
+  URL: string;
+  DISABLE_DOCS: boolean;
+  DISABLE_MANAGER: boolean;
+};
 
 export type HttpMethods = 'POST' | 'GET' | 'PUT' | 'DELETE';
 export type Cors = {
@@ -66,12 +72,22 @@ export type Rabbitmq = {
   URI: string;
 };
 
+export type Sqs = {
+  ENABLED: boolean;
+  ACCESS_KEY_ID: string;
+  SECRET_ACCESS_KEY: string;
+  ACCOUNT_ID: string;
+  REGION: string;
+};
+
 export type Websocket = {
   ENABLED: boolean;
 };
 
 export type EventsWebhook = {
   APPLICATION_STARTUP: boolean;
+  INSTANCE_CREATE: boolean;
+  INSTANCE_DELETE: boolean;
   QRCODE_UPDATED: boolean;
   MESSAGES_SET: boolean;
   MESSAGES_UPSERT: boolean;
@@ -92,6 +108,11 @@ export type EventsWebhook = {
   GROUP_PARTICIPANTS_UPDATE: boolean;
   CALL: boolean;
   NEW_JWT_TOKEN: boolean;
+  TYPEBOT_START: boolean;
+  TYPEBOT_CHANGE_STATUS: boolean;
+  CHAMA_AI_ACTION: boolean;
+  ERRORS: boolean;
+  ERRORS_WEBHOOK: string;
 };
 
 export type ApiKey = { KEY: string };
@@ -115,6 +136,7 @@ export type SslConf = { PRIVKEY: string; FULLCHAIN: string };
 export type Webhook = { GLOBAL?: GlobalWebhook; EVENTS: EventsWebhook };
 export type ConfigSessionPhone = { CLIENT: string; NAME: string };
 export type QrCode = { LIMIT: number; COLOR: string };
+export type Typebot = { API_VERSION: string; KEEP_OPEN: boolean };
 export type Production = boolean;
 
 export interface Env {
@@ -126,12 +148,14 @@ export interface Env {
   DATABASE: Database;
   REDIS: Redis;
   RABBITMQ: Rabbitmq;
+  SQS: Sqs;
   WEBSOCKET: Websocket;
   LOG: Log;
   DEL_INSTANCE: DelInstance;
   WEBHOOK: Webhook;
   CONFIG_SESSION_PHONE: ConfigSessionPhone;
   QRCODE: QrCode;
+  TYPEBOT: Typebot;
   AUTHENTICATION: Auth;
   PRODUCTION?: Production;
 }
@@ -153,8 +177,8 @@ export class ConfigService {
     this.env = !(process.env?.DOCKER_ENV === 'true') ? this.envYaml() : this.envProcess();
     this.env.PRODUCTION = process.env?.NODE_ENV === 'PROD';
     if (process.env?.DOCKER_ENV === 'true') {
-      this.env.SERVER.TYPE = 'http';
-      this.env.SERVER.PORT = 8080;
+      this.env.SERVER.TYPE = process.env.SERVER_TYPE as 'http' | 'http';
+      this.env.SERVER.PORT = Number.parseInt(process.env.SERVER_PORT) || 8080;
     }
   }
 
@@ -165,18 +189,20 @@ export class ConfigService {
   private envProcess(): Env {
     return {
       SERVER: {
-        TYPE: process.env.SERVER_TYPE as 'http' | 'https',
-        PORT: Number.parseInt(process.env.SERVER_PORT),
+        TYPE: (process.env.SERVER_TYPE as 'http' | 'https') || 'http',
+        PORT: Number.parseInt(process.env.SERVER_PORT) || 8080,
         URL: process.env.SERVER_URL,
+        DISABLE_DOCS: process.env?.SERVER_DISABLE_DOCS === 'true',
+        DISABLE_MANAGER: process.env?.SERVER_DISABLE_MANAGER === 'true',
       },
       CORS: {
-        ORIGIN: process.env.CORS_ORIGIN.split(','),
-        METHODS: process.env.CORS_METHODS.split(',') as HttpMethods[],
+        ORIGIN: process.env.CORS_ORIGIN.split(',') || ['*'],
+        METHODS: (process.env.CORS_METHODS.split(',') as HttpMethods[]) || ['POST', 'GET', 'PUT', 'DELETE'],
         CREDENTIALS: process.env?.CORS_CREDENTIALS === 'true',
       },
       SSL_CONF: {
-        PRIVKEY: process.env?.SSL_CONF_PRIVKEY,
-        FULLCHAIN: process.env?.SSL_CONF_FULLCHAIN,
+        PRIVKEY: process.env?.SSL_CONF_PRIVKEY || '',
+        FULLCHAIN: process.env?.SSL_CONF_FULLCHAIN || '',
       },
       STORE: {
         MESSAGES: process.env?.STORE_MESSAGES === 'true',
@@ -195,8 +221,8 @@ export class ConfigService {
       },
       DATABASE: {
         CONNECTION: {
-          URI: process.env.DATABASE_CONNECTION_URI,
-          DB_PREFIX_NAME: process.env.DATABASE_CONNECTION_DB_PREFIX_NAME,
+          URI: process.env.DATABASE_CONNECTION_URI || '',
+          DB_PREFIX_NAME: process.env.DATABASE_CONNECTION_DB_PREFIX_NAME || 'evolution',
         },
         ENABLED: process.env?.DATABASE_ENABLED === 'true',
         SAVE_DATA: {
@@ -209,18 +235,34 @@ export class ConfigService {
       },
       REDIS: {
         ENABLED: process.env?.REDIS_ENABLED === 'true',
-        URI: process.env.REDIS_URI,
-        PREFIX_KEY: process.env.REDIS_PREFIX_KEY,
+        URI: process.env.REDIS_URI || '',
+        PREFIX_KEY: process.env.REDIS_PREFIX_KEY || 'evolution',
       },
       RABBITMQ: {
         ENABLED: process.env?.RABBITMQ_ENABLED === 'true',
-        URI: process.env.RABBITMQ_URI,
+        URI: process.env.RABBITMQ_URI || '',
+      },
+      SQS: {
+        ENABLED: process.env?.SQS_ENABLED === 'true',
+        ACCESS_KEY_ID: process.env.SQS_ACCESS_KEY_ID || '',
+        SECRET_ACCESS_KEY: process.env.SQS_SECRET_ACCESS_KEY || '',
+        ACCOUNT_ID: process.env.SQS_ACCOUNT_ID || '',
+        REGION: process.env.SQS_REGION || '',
       },
       WEBSOCKET: {
         ENABLED: process.env?.WEBSOCKET_ENABLED === 'true',
       },
       LOG: {
-        LEVEL: process.env?.LOG_LEVEL.split(',') as LogLevel[],
+        LEVEL: (process.env?.LOG_LEVEL.split(',') as LogLevel[]) || [
+          'ERROR',
+          'WARN',
+          'DEBUG',
+          'INFO',
+          'LOG',
+          'VERBOSE',
+          'DARK',
+          'WEBHOOKS',
+        ],
         COLOR: process.env?.LOG_COLOR === 'true',
         BAILEYS: (process.env?.LOG_BAILEYS as LogBaileys) || 'error',
       },
@@ -229,12 +271,14 @@ export class ConfigService {
         : Number.parseInt(process.env.DEL_INSTANCE) || false,
       WEBHOOK: {
         GLOBAL: {
-          URL: process.env?.WEBHOOK_GLOBAL_URL,
+          URL: process.env?.WEBHOOK_GLOBAL_URL || '',
           ENABLED: process.env?.WEBHOOK_GLOBAL_ENABLED === 'true',
           WEBHOOK_BY_EVENTS: process.env?.WEBHOOK_GLOBAL_WEBHOOK_BY_EVENTS === 'true',
         },
         EVENTS: {
           APPLICATION_STARTUP: process.env?.WEBHOOK_EVENTS_APPLICATION_STARTUP === 'true',
+          INSTANCE_CREATE: process.env?.WEBHOOK_EVENTS_INSTANCE_CREATE === 'true',
+          INSTANCE_DELETE: process.env?.WEBHOOK_EVENTS_INSTANCE_DELETE === 'true',
           QRCODE_UPDATED: process.env?.WEBHOOK_EVENTS_QRCODE_UPDATED === 'true',
           MESSAGES_SET: process.env?.WEBHOOK_EVENTS_MESSAGES_SET === 'true',
           MESSAGES_UPSERT: process.env?.WEBHOOK_EVENTS_MESSAGES_UPSERT === 'true',
@@ -255,27 +299,36 @@ export class ConfigService {
           GROUP_PARTICIPANTS_UPDATE: process.env?.WEBHOOK_EVENTS_GROUP_PARTICIPANTS_UPDATE === 'true',
           CALL: process.env?.WEBHOOK_EVENTS_CALL === 'true',
           NEW_JWT_TOKEN: process.env?.WEBHOOK_EVENTS_NEW_JWT_TOKEN === 'true',
+          TYPEBOT_START: process.env?.WEBHOOK_EVENTS_TYPEBOT_START === 'true',
+          TYPEBOT_CHANGE_STATUS: process.env?.WEBHOOK_EVENTS_TYPEBOT_CHANGE_STATUS === 'true',
+          CHAMA_AI_ACTION: process.env?.WEBHOOK_EVENTS_CHAMA_AI_ACTION === 'true',
+          ERRORS: process.env?.WEBHOOK_EVENTS_ERRORS === 'true',
+          ERRORS_WEBHOOK: process.env?.WEBHOOK_EVENTS_ERRORS_WEBHOOK || '',
         },
       },
       CONFIG_SESSION_PHONE: {
         CLIENT: process.env?.CONFIG_SESSION_PHONE_CLIENT || 'Evolution API',
-        NAME: process.env?.CONFIG_SESSION_PHONE_NAME || 'chrome',
+        NAME: process.env?.CONFIG_SESSION_PHONE_NAME || 'Chrome',
       },
       QRCODE: {
         LIMIT: Number.parseInt(process.env.QRCODE_LIMIT) || 30,
         COLOR: process.env.QRCODE_COLOR || '#198754',
       },
+      TYPEBOT: {
+        API_VERSION: process.env?.TYPEBOT_API_VERSION || 'old',
+        KEEP_OPEN: process.env.TYPEBOT_KEEP_OPEN === 'true',
+      },
       AUTHENTICATION: {
-        TYPE: process.env.AUTHENTICATION_TYPE as 'jwt',
+        TYPE: process.env.AUTHENTICATION_TYPE as 'apikey',
         API_KEY: {
-          KEY: process.env.AUTHENTICATION_API_KEY,
+          KEY: process.env.AUTHENTICATION_API_KEY || 'BQYHJGJHJ',
         },
         EXPOSE_IN_FETCH_INSTANCES: process.env?.AUTHENTICATION_EXPOSE_IN_FETCH_INSTANCES === 'true',
         JWT: {
           EXPIRIN_IN: Number.isInteger(process.env?.AUTHENTICATION_JWT_EXPIRIN_IN)
             ? Number.parseInt(process.env.AUTHENTICATION_JWT_EXPIRIN_IN)
             : 3600,
-          SECRET: process.env.AUTHENTICATION_JWT_SECRET,
+          SECRET: process.env.AUTHENTICATION_JWT_SECRET || 'L=0YWt]b2w[WF>#>:&E`',
         },
       },
     };

src/dev-env.yml

@@ -9,6 +9,9 @@ SERVER:
   TYPE: http # https
   PORT: 8080 # 443
   URL: localhost
+  DISABLE_MANAGER: false
+  DISABLE_DOCS: false
+
 
 CORS:
   ORIGIN:
@@ -83,7 +86,14 @@ RABBITMQ:
   ENABLED: false
   URI: "amqp://guest:guest@localhost:5672"
 
-WEBSOCKET: 
+SQS:
+  ENABLED: true
+  ACCESS_KEY_ID: ""
+  SECRET_ACCESS_KEY: ""
+  ACCOUNT_ID: ""
+  REGION: "us-east-1"
+
+WEBSOCKET:
   ENABLED: false
 
 # Global Webhook Settings
@@ -120,16 +130,28 @@ WEBHOOK:
     CALL: true
     # This event fires every time a new token is requested via the refresh route
     NEW_JWT_TOKEN: false
+    # This events is used with Typebot
+    TYPEBOT_START: false
+    TYPEBOT_CHANGE_STATUS: false
+    # This event is used with Chama AI
+    CHAMA_AI_ACTION: false
+    # This event is used to send errors to the webhook
+    ERRORS: false
+    ERRORS_WEBHOOK: <url>
 
 CONFIG_SESSION_PHONE:
   # Name that will be displayed on smartphone connection
   CLIENT: "Evolution API"
-  NAME: chrome # chrome | firefox | edge | opera | safari
+  NAME: Chrome # Chrome | Firefox | Edge | Opera | Safari
 
 # Set qrcode display limit
 QRCODE:
   LIMIT: 30
-  COLOR: '#198754'
+  COLOR: "#198754"
+
+TYPEBOT:
+  API_VERSION: 'old' # old | latest
+  KEEP_OPEN: false
 
 # Defines an authentication type for the api
 # We recommend using the apikey because it will allow you to use a custom token,
@@ -145,4 +167,4 @@ AUTHENTICATION:
   # Set the secret key to encrypt and decrypt your token and its expiration time.
   JWT:
     EXPIRIN_IN: 0 # seconds - 3600s === 1h | zero (0) - never expires
-    SECRET: L=0YWt]b2w[WF>#>:&E`
+    SECRET: L=0YWt]b2w[WF>#>:&E`

src/docs/swagger.conf.ts

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+import { join } from 'path';
+import swaggerUi from 'swagger-ui-express';
+import YAML from 'yamljs';
+
+const document = YAML.load(join(process.cwd(), 'src', 'docs', 'swagger.yaml'));
+
+const router = Router();
+
+export const swaggerRouter = router.use('/docs', swaggerUi.serve).get(
+  '/docs',
+  swaggerUi.setup(document, {
+    customCssUrl: '/css/dark-theme-swagger.css',
+    customSiteTitle: 'Evolution API',
+    customfavIcon: '/images/logo.svg',
+  }),
+);

src/libs/amqp.server.ts

@@ -41,3 +41,60 @@ export const initAMQP = () => {
 export const getAMQP = (): amqp.Channel | null => {
   return amqpChannel;
 };
+
+export const initQueues = (instanceName: string, events: string[]) => {
+  if (!events || !events.length) return;
+
+  const queues = events.map((event) => {
+    return `${event.replace(/_/g, '.').toLowerCase()}`;
+  });
+
+  queues.forEach((event) => {
+    const amqp = getAMQP();
+    const exchangeName = instanceName ?? 'evolution_exchange';
+
+    amqp.assertExchange(exchangeName, 'topic', {
+      durable: true,
+      autoDelete: false,
+    });
+
+    const queueName = `${instanceName}.${event}`;
+
+    amqp.assertQueue(queueName, {
+      durable: true,
+      autoDelete: false,
+      arguments: {
+        'x-queue-type': 'quorum',
+      },
+    });
+
+    amqp.bindQueue(queueName, exchangeName, event);
+  });
+};
+
+export const removeQueues = (instanceName: string, events: string[]) => {
+  if (!events || !events.length) return;
+
+  const channel = getAMQP();
+
+  const queues = events.map((event) => {
+    return `${event.replace(/_/g, '.').toLowerCase()}`;
+  });
+
+  const exchangeName = instanceName ?? 'evolution_exchange';
+
+  queues.forEach((event) => {
+    const amqp = getAMQP();
+
+    amqp.assertExchange(exchangeName, 'topic', {
+      durable: true,
+      autoDelete: false,
+    });
+
+    const queueName = `${instanceName}.${event}`;
+
+    amqp.deleteQueue(queueName);
+  });
+
+  channel.deleteExchange(exchangeName);
+};

src/libs/redis.client.ts

@@ -5,45 +5,55 @@ import { Redis } from '../config/env.config';
 import { Logger } from '../config/logger.config';
 
 export class RedisCache {
-  constructor() {
-    this.logger.verbose('instance created');
-    process.on('beforeExit', async () => {
-      this.logger.verbose('instance destroyed');
-      if (this.statusConnection) {
-        this.logger.verbose('instance disconnect');
-        await this.client.disconnect();
-      }
-    });
-  }
-
+  private readonly logger = new Logger(RedisCache.name);
+  private client: RedisClientType;
   private statusConnection = false;
   private instanceName: string;
   private redisEnv: Redis;
 
+  constructor() {
+    this.logger.verbose('RedisCache instance created');
+    process.on('beforeExit', () => {
+      this.logger.verbose('RedisCache instance destroyed');
+      this.disconnect();
+    });
+  }
+
   public set reference(reference: string) {
     this.logger.verbose('set reference: ' + reference);
     this.instanceName = reference;
   }
 
   public async connect(redisEnv: Redis) {
-    this.logger.verbose('connecting');
+    this.logger.verbose('Connecting to Redis...');
     this.client = createClient({ url: redisEnv.URI });
-    this.logger.verbose('connected in ' + redisEnv.URI);
+    this.client.on('error', (err) => this.logger.error('Redis Client Error ' + err));
+
     await this.client.connect();
     this.statusConnection = true;
     this.redisEnv = redisEnv;
+    this.logger.verbose(`Connected to ${redisEnv.URI}`);
   }
 
-  private readonly logger = new Logger(RedisCache.name);
-  private client: RedisClientType;
+  public async disconnect() {
+    if (this.statusConnection) {
+      await this.client.disconnect();
+      this.statusConnection = false;
+      this.logger.verbose('Redis client disconnected');
+    }
+  }
 
   public async instanceKeys(): Promise<string[]> {
+    const keys: string[] = [];
     try {
-      this.logger.verbose('instance keys: ' + this.redisEnv.PREFIX_KEY + ':*');
-      return await this.client.sendCommand(['keys', this.redisEnv.PREFIX_KEY + ':*']);
+      this.logger.verbose('Fetching instance keys');
+      for await (const key of this.client.scanIterator({ MATCH: `${this.redisEnv.PREFIX_KEY}:*` })) {
+        keys.push(key);
+      }
     } catch (error) {
-      this.logger.error(error);
+      this.logger.error('Error fetching instance keys ' + error);
     }
+    return keys;
   }
 
   public async keyExists(key?: string) {

src/libs/socket.server.ts

@@ -11,7 +11,7 @@ let io: SocketIO;
 const cors = configService.get<Cors>('CORS').ORIGIN;
 
 export const initIO = (httpServer: Server) => {
-  if (configService.get<Websocket>('WEBSOCKET').ENABLED) {
+  if (configService.get<Websocket>('WEBSOCKET')?.ENABLED) {
     io = new SocketIO(httpServer, {
       cors: {
         origin: cors,

src/libs/sqs.server.ts

@@ -0,0 +1,97 @@
+import { SQS } from 'aws-sdk';
+
+import { configService, Sqs } from '../config/env.config';
+import { Logger } from '../config/logger.config';
+
+const logger = new Logger('SQS');
+
+let sqs: SQS;
+
+export const initSQS = () => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  return new Promise<void>((resolve, reject) => {
+    const awsConfig = configService.get<Sqs>('SQS');
+    sqs = new SQS({
+      accessKeyId: awsConfig.ACCESS_KEY_ID,
+      secretAccessKey: awsConfig.SECRET_ACCESS_KEY,
+      region: awsConfig.REGION,
+    });
+
+    logger.info('SQS initialized');
+    resolve();
+  });
+};
+
+export const getSQS = (): SQS => {
+  return sqs;
+};
+
+export const initQueues = (instanceName: string, events: string[]) => {
+  if (!events || !events.length) return;
+
+  const queues = events.map((event) => {
+    return `${event.replace(/_/g, '_').toLowerCase()}`;
+  });
+
+  const sqs = getSQS();
+
+  queues.forEach((event) => {
+    const queueName = `${instanceName}_${event}.fifo`;
+
+    sqs.createQueue(
+      {
+        QueueName: queueName,
+        Attributes: {
+          FifoQueue: 'true',
+        },
+      },
+      (err, data) => {
+        if (err) {
+          logger.error(`Error creating queue ${queueName}: ${err.message}`);
+        } else {
+          logger.info(`Queue ${queueName} created: ${data.QueueUrl}`);
+        }
+      },
+    );
+  });
+};
+
+export const removeQueues = (instanceName: string, events: string[]) => {
+  if (!events || !events.length) return;
+
+  const sqs = getSQS();
+
+  const queues = events.map((event) => {
+    return `${event.replace(/_/g, '_').toLowerCase()}`;
+  });
+
+  queues.forEach((event) => {
+    const queueName = `${instanceName}_${event}.fifo`;
+
+    sqs.getQueueUrl(
+      {
+        QueueName: queueName,
+      },
+      (err, data) => {
+        if (err) {
+          logger.error(`Error getting queue URL for ${queueName}: ${err.message}`);
+        } else {
+          const queueUrl = data.QueueUrl;
+
+          sqs.deleteQueue(
+            {
+              QueueUrl: queueUrl,
+            },
+            (deleteErr) => {
+              if (deleteErr) {
+                logger.error(`Error deleting queue ${queueName}: ${deleteErr.message}`);
+              } else {
+                logger.info(`Queue ${queueName} deleted`);
+              }
+            },
+          );
+        }
+      },
+    );
+  });
+};

src/main.ts

@@ -1,16 +1,19 @@
 import 'express-async-errors';
 
+import axios from 'axios';
 import compression from 'compression';
 import cors from 'cors';
 import express, { json, NextFunction, Request, Response, urlencoded } from 'express';
 import { join } from 'path';
 
-import { configService, Cors, HttpServer, Rabbitmq } from './config/env.config';
+import { Auth, configService, Cors, HttpServer, Rabbitmq, Sqs, Webhook } from './config/env.config';
 import { onUnexpectedError } from './config/error.config';
 import { Logger } from './config/logger.config';
 import { ROOT_DIR } from './config/path.config';
+import { swaggerRouter } from './docs/swagger.conf';
 import { initAMQP } from './libs/amqp.server';
 import { initIO } from './libs/socket.server';
+import { initSQS } from './libs/sqs.server';
 import { ServerUP } from './utils/server-up';
 import { HttpStatus, router } from './whatsapp/routers/index.router';
 import { waMonitor } from './whatsapp/whatsapp.module';
@@ -47,11 +50,47 @@ function bootstrap() {
   app.set('views', join(ROOT_DIR, 'views'));
   app.use(express.static(join(ROOT_DIR, 'public')));
 
+  app.use('/store', express.static(join(ROOT_DIR, 'store')));
+
   app.use('/', router);
 
+  if (!configService.get('SERVER').DISABLE_DOCS) app.use(swaggerRouter);
+
   app.use(
     (err: Error, req: Request, res: Response, next: NextFunction) => {
       if (err) {
+        const webhook = configService.get<Webhook>('WEBHOOK');
+
+        if (webhook.EVENTS.ERRORS_WEBHOOK && webhook.EVENTS.ERRORS_WEBHOOK != '' && webhook.EVENTS.ERRORS) {
+          const tzoffset = new Date().getTimezoneOffset() * 60000; //offset in milliseconds
+          const localISOTime = new Date(Date.now() - tzoffset).toISOString();
+          const now = localISOTime;
+          const globalApiKey = configService.get<Auth>('AUTHENTICATION').API_KEY.KEY;
+          const serverUrl = configService.get<HttpServer>('SERVER').URL;
+
+          const errorData = {
+            event: 'error',
+            data: {
+              error: err['error'] || 'Internal Server Error',
+              message: err['message'] || 'Internal Server Error',
+              status: err['status'] || 500,
+              response: {
+                message: err['message'] || 'Internal Server Error',
+              },
+            },
+            date_time: now,
+            api_key: globalApiKey,
+            server_url: serverUrl,
+          };
+
+          logger.error(errorData);
+
+          const baseURL = webhook.EVENTS.ERRORS_WEBHOOK;
+          const httpService = axios.create({ baseURL });
+
+          httpService.post('', errorData);
+        }
+
         return res.status(err['status'] || 500).json({
           status: err['status'] || 500,
           error: err['error'] || 'Internal Server Error',
@@ -89,7 +128,9 @@ function bootstrap() {
 
   initIO(server);
 
-  if (configService.get<Rabbitmq>('RABBITMQ').ENABLED) initAMQP();
+  if (configService.get<Rabbitmq>('RABBITMQ')?.ENABLED) initAMQP();
+
+  if (configService.get<Sqs>('SQS')?.ENABLED) initSQS();
 
   onUnexpectedError();
 }

src/utils/use-multi-file-auth-state-db.ts

@@ -25,7 +25,14 @@ export async function useMultiFileAuthStateDb(
   const writeData = async (data: any, key: string): Promise<any> => {
     try {
       await client.connect();
-      return await collection.replaceOne({ _id: key }, JSON.parse(JSON.stringify(data, BufferJSON.replacer)), {
+      let msgParsed = JSON.parse(JSON.stringify(data, BufferJSON.replacer));
+      if (Array.isArray(msgParsed)) {
+        msgParsed = {
+          _id: key,
+          content_array: msgParsed,
+        };
+      }
+      return await collection.replaceOne({ _id: key }, msgParsed, {
         upsert: true,
       });
     } catch (error) {
@@ -36,7 +43,10 @@ export async function useMultiFileAuthStateDb(
   const readData = async (key: string): Promise<any> => {
     try {
       await client.connect();
-      const data = await collection.findOne({ _id: key });
+      let data = (await collection.findOne({ _id: key })) as any;
+      if (data?.content_array) {
+        data = data.content_array;
+      }
       const creds = JSON.stringify(data);
       return JSON.parse(creds, BufferJSON.reviver);
     } catch (error) {
@@ -91,7 +101,7 @@ export async function useMultiFileAuthStateDb(
       },
     },
     saveCreds: async () => {
-      return writeData(creds, 'creds');
+      return await writeData(creds, 'creds');
     },
   };
 }

src/validate/validate.schema.ts

@@ -55,6 +55,9 @@ export const instanceNameSchema: JSONSchema7 = {
           'CONNECTION_UPDATE',
           'CALL',
           'NEW_JWT_TOKEN',
+          'TYPEBOT_START',
+          'TYPEBOT_CHANGE_STATUS',
+          'CHAMA_AI_ACTION',
         ],
       },
     },
@@ -146,6 +149,16 @@ export const textMessageSchema: JSONSchema7 = {
   required: ['textMessage', 'number'],
 };
 
+export const presenceSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    number: { ...numberDefinition },
+    options: { ...optionsSchema, required: ['presence', 'delay'] },
+  },
+  required: ['options', 'number'],
+};
+
 export const pollMessageSchema: JSONSchema7 = {
   $id: v4(),
   type: 'object',
@@ -856,6 +869,9 @@ export const webhookSchema: JSONSchema7 = {
           'CONNECTION_UPDATE',
           'CALL',
           'NEW_JWT_TOKEN',
+          'TYPEBOT_START',
+          'TYPEBOT_CHANGE_STATUS',
+          'CHAMA_AI_ACTION',
         ],
       },
     },
@@ -873,8 +889,10 @@ export const chatwootSchema: JSONSchema7 = {
     token: { type: 'string' },
     url: { type: 'string' },
     sign_msg: { type: 'boolean', enum: [true, false] },
+    sign_delimiter: { type: ['string', 'null'] },
     reopen_conversation: { type: 'boolean', enum: [true, false] },
     conversation_pending: { type: 'boolean', enum: [true, false] },
+    auto_create: { type: 'boolean', enum: [true, false] },
   },
   required: ['enabled', 'account_id', 'token', 'url', 'sign_msg', 'reopen_conversation', 'conversation_pending'],
   ...isNotEmpty('account_id', 'token', 'url', 'sign_msg', 'reopen_conversation', 'conversation_pending'),
@@ -927,6 +945,9 @@ export const websocketSchema: JSONSchema7 = {
           'CONNECTION_UPDATE',
           'CALL',
           'NEW_JWT_TOKEN',
+          'TYPEBOT_START',
+          'TYPEBOT_CHANGE_STATUS',
+          'CHAMA_AI_ACTION',
         ],
       },
     },
@@ -967,6 +988,52 @@ export const rabbitmqSchema: JSONSchema7 = {
           'CONNECTION_UPDATE',
           'CALL',
           'NEW_JWT_TOKEN',
+          'TYPEBOT_START',
+          'TYPEBOT_CHANGE_STATUS',
+          'CHAMA_AI_ACTION',
+        ],
+      },
+    },
+  },
+  required: ['enabled'],
+  ...isNotEmpty('enabled'),
+};
+
+export const sqsSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    enabled: { type: 'boolean', enum: [true, false] },
+    events: {
+      type: 'array',
+      minItems: 0,
+      items: {
+        type: 'string',
+        enum: [
+          'APPLICATION_STARTUP',
+          'QRCODE_UPDATED',
+          'MESSAGES_SET',
+          'MESSAGES_UPSERT',
+          'MESSAGES_UPDATE',
+          'MESSAGES_DELETE',
+          'SEND_MESSAGE',
+          'CONTACTS_SET',
+          'CONTACTS_UPSERT',
+          'CONTACTS_UPDATE',
+          'PRESENCE_UPDATE',
+          'CHATS_SET',
+          'CHATS_UPSERT',
+          'CHATS_UPDATE',
+          'CHATS_DELETE',
+          'GROUPS_UPSERT',
+          'GROUP_UPDATE',
+          'GROUP_PARTICIPANTS_UPDATE',
+          'CONNECTION_UPDATE',
+          'CALL',
+          'NEW_JWT_TOKEN',
+          'TYPEBOT_START',
+          'TYPEBOT_CHANGE_STATUS',
+          'CHAMA_AI_ACTION',
         ],
       },
     },
@@ -985,9 +1052,10 @@ export const typebotSchema: JSONSchema7 = {
     expire: { type: 'integer' },
     delay_message: { type: 'integer' },
     unknown_message: { type: 'string' },
+    listening_from_me: { type: 'boolean', enum: [true, false] },
   },
-  required: ['enabled', 'url', 'typebot', 'expire'],
-  ...isNotEmpty('enabled', 'url', 'typebot', 'expire'),
+  required: ['enabled', 'url', 'typebot', 'expire', 'delay_message', 'unknown_message', 'listening_from_me'],
+  ...isNotEmpty('enabled', 'url', 'typebot', 'expire', 'delay_message', 'unknown_message', 'listening_from_me'),
 };
 
 export const typebotStatusSchema: JSONSchema7 = {
@@ -1023,3 +1091,17 @@ export const proxySchema: JSONSchema7 = {
   required: ['enabled', 'proxy'],
   ...isNotEmpty('enabled', 'proxy'),
 };
+
+export const chamaaiSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    enabled: { type: 'boolean', enum: [true, false] },
+    url: { type: 'string' },
+    token: { type: 'string' },
+    waNumber: { type: 'string' },
+    answerByAudio: { type: 'boolean', enum: [true, false] },
+  },
+  required: ['enabled', 'url', 'token', 'waNumber', 'answerByAudio'],
+  ...isNotEmpty('enabled', 'url', 'token', 'waNumber', 'answerByAudio'),
+};

src/whatsapp/controllers/chamaai.controller.ts

@@ -0,0 +1,29 @@
+import { Logger } from '../../config/logger.config';
+import { ChamaaiDto } from '../dto/chamaai.dto';
+import { InstanceDto } from '../dto/instance.dto';
+import { ChamaaiService } from '../services/chamaai.service';
+
+const logger = new Logger('ChamaaiController');
+
+export class ChamaaiController {
+  constructor(private readonly chamaaiService: ChamaaiService) {}
+
+  public async createChamaai(instance: InstanceDto, data: ChamaaiDto) {
+    logger.verbose('requested createChamaai from ' + instance.instanceName + ' instance');
+
+    if (!data.enabled) {
+      logger.verbose('chamaai disabled');
+      data.url = '';
+      data.token = '';
+      data.waNumber = '';
+      data.answerByAudio = false;
+    }
+
+    return this.chamaaiService.create(instance, data);
+  }
+
+  public async findChamaai(instance: InstanceDto) {
+    logger.verbose('requested findChamaai from ' + instance.instanceName + ' instance');
+    return this.chamaaiService.find(instance);
+  }
+}

src/whatsapp/controllers/chat.controller.ts

@@ -9,6 +9,7 @@ import {
   ProfilePictureDto,
   ProfileStatusDto,
   ReadMessageDto,
+  SendPresenceDto,
   WhatsAppNumberDto,
 } from '../dto/chat.dto';
 import { InstanceDto } from '../dto/instance.dto';
@@ -77,6 +78,11 @@ export class ChatController {
     return await this.waMonitor.waInstances[instanceName].fetchChats();
   }
 
+  public async sendPresence({ instanceName }: InstanceDto, data: SendPresenceDto) {
+    logger.verbose('requested sendPresence from ' + instanceName + ' instance');
+    return await this.waMonitor.waInstances[instanceName].sendPresence(data);
+  }
+
   public async fetchPrivacySettings({ instanceName }: InstanceDto) {
     logger.verbose('requested fetchPrivacySettings from ' + instanceName + ' instance');
     return await this.waMonitor.waInstances[instanceName].fetchPrivacySettings();

src/whatsapp/controllers/chatwoot.controller.ts

@@ -5,13 +5,18 @@ import { Logger } from '../../config/logger.config';
 import { BadRequestException } from '../../exceptions';
 import { ChatwootDto } from '../dto/chatwoot.dto';
 import { InstanceDto } from '../dto/instance.dto';
+import { RepositoryBroker } from '../repository/repository.manager';
 import { ChatwootService } from '../services/chatwoot.service';
 import { waMonitor } from '../whatsapp.module';
 
 const logger = new Logger('ChatwootController');
 
 export class ChatwootController {
-  constructor(private readonly chatwootService: ChatwootService, private readonly configService: ConfigService) {}
+  constructor(
+    private readonly chatwootService: ChatwootService,
+    private readonly configService: ConfigService,
+    private readonly repository: RepositoryBroker,
+  ) {}
 
   public async createChatwoot(instance: InstanceDto, data: ChatwootDto) {
     logger.verbose('requested createChatwoot from ' + instance.instanceName + ' instance');
@@ -32,6 +37,7 @@ export class ChatwootController {
       if (data.sign_msg !== true && data.sign_msg !== false) {
         throw new BadRequestException('sign_msg is required');
       }
+      if (data.sign_msg === false) data.sign_delimiter = null;
     }
 
     if (!data.enabled) {
@@ -40,13 +46,15 @@ export class ChatwootController {
       data.token = '';
       data.url = '';
       data.sign_msg = false;
+      data.sign_delimiter = null;
       data.reopen_conversation = false;
       data.conversation_pending = false;
+      data.auto_create = false;
     }
 
     data.name_inbox = instance.instanceName;
 
-    const result = this.chatwootService.create(instance, data);
+    const result = await this.chatwootService.create(instance, data);
 
     const urlServer = this.configService.get<HttpServer>('SERVER').URL;
 
@@ -64,7 +72,7 @@ export class ChatwootController {
 
     const urlServer = this.configService.get<HttpServer>('SERVER').URL;
 
-    if (Object.keys(result).length === 0) {
+    if (Object.keys(result || {}).length === 0) {
       return {
         enabled: false,
         url: '',
@@ -86,7 +94,7 @@ export class ChatwootController {
 
   public async receiveWebhook(instance: InstanceDto, data: any) {
     logger.verbose('requested receiveWebhook from ' + instance.instanceName + ' instance');
-    const chatwootService = new ChatwootService(waMonitor, this.configService);
+    const chatwootService = new ChatwootService(waMonitor, this.configService, this.repository);
 
     return chatwootService.receiveWebhook(instance, data);
   }

src/whatsapp/controllers/instance.controller.ts

@@ -1,6 +1,7 @@
 import { delay } from '@whiskeysockets/baileys';
 import { isURL } from 'class-validator';
 import EventEmitter2 from 'eventemitter2';
+import { v4 } from 'uuid';
 
 import { ConfigService, HttpServer } from '../../config/env.config';
 import { Logger } from '../../config/logger.config';
@@ -11,13 +12,15 @@ import { RepositoryBroker } from '../repository/repository.manager';
 import { AuthService, OldToken } from '../services/auth.service';
 import { ChatwootService } from '../services/chatwoot.service';
 import { WAMonitoringService } from '../services/monitor.service';
+import { ProxyService } from '../services/proxy.service';
 import { RabbitmqService } from '../services/rabbitmq.service';
 import { SettingsService } from '../services/settings.service';
+import { SqsService } from '../services/sqs.service';
 import { TypebotService } from '../services/typebot.service';
 import { WebhookService } from '../services/webhook.service';
 import { WebsocketService } from '../services/websocket.service';
 import { WAStartupService } from '../services/whatsapp.service';
-import { wa } from '../types/wa.types';
+import { Events, wa } from '../types/wa.types';
 
 export class InstanceController {
   constructor(
@@ -31,6 +34,8 @@ export class InstanceController {
     private readonly settingsService: SettingsService,
     private readonly websocketService: WebsocketService,
     private readonly rabbitmqService: RabbitmqService,
+    private readonly proxyService: ProxyService,
+    private readonly sqsService: SqsService,
     private readonly typebotService: TypebotService,
     private readonly cache: RedisCache,
   ) {}
@@ -41,6 +46,7 @@ export class InstanceController {
     instanceName,
     webhook,
     webhook_by_events,
+    webhook_base64,
     events,
     qrcode,
     number,
@@ -61,12 +67,16 @@ export class InstanceController {
     websocket_events,
     rabbitmq_enabled,
     rabbitmq_events,
+    sqs_enabled,
+    sqs_events,
     typebot_url,
     typebot,
     typebot_expire,
     typebot_keyword_finish,
     typebot_delay_message,
     typebot_unknown_message,
+    typebot_listening_from_me,
+    proxy,
   }: InstanceDto) {
     try {
       this.logger.verbose('requested createInstance from ' + instanceName + ' instance');
@@ -78,6 +88,13 @@ export class InstanceController {
       const instance = new WAStartupService(this.configService, this.eventEmitter, this.repository, this.cache);
       instance.instanceName = instanceName;
 
+      const instanceId = v4();
+
+      instance.sendDataWebhook(Events.INSTANCE_CREATE, {
+        instanceName,
+        instanceId: instanceId,
+      });
+
       this.logger.verbose('instance: ' + instance.instanceName + ' created');
 
       this.waMonitor.waInstances[instance.instanceName] = instance;
@@ -87,6 +104,7 @@ export class InstanceController {
       const hash = await this.authService.generateHash(
         {
           instanceName: instance.instanceName,
+          instanceId: instanceId,
         },
         token,
       );
@@ -126,6 +144,9 @@ export class InstanceController {
               'CONNECTION_UPDATE',
               'CALL',
               'NEW_JWT_TOKEN',
+              'TYPEBOT_START',
+              'TYPEBOT_CHANGE_STATUS',
+              'CHAMA_AI_ACTION',
             ];
           } else {
             newEvents = events;
@@ -135,6 +156,7 @@ export class InstanceController {
             url: webhook,
             events: newEvents,
             webhook_by_events,
+            webhook_base64,
           });
 
           webhookEvents = (await this.webhookService.find(instance)).events;
@@ -172,9 +194,12 @@ export class InstanceController {
               'CONNECTION_UPDATE',
               'CALL',
               'NEW_JWT_TOKEN',
+              'TYPEBOT_START',
+              'TYPEBOT_CHANGE_STATUS',
+              'CHAMA_AI_ACTION',
             ];
           } else {
-            newEvents = events;
+            newEvents = websocket_events;
           }
           this.websocketService.create(instance, {
             enabled: true,
@@ -216,9 +241,12 @@ export class InstanceController {
               'CONNECTION_UPDATE',
               'CALL',
               'NEW_JWT_TOKEN',
+              'TYPEBOT_START',
+              'TYPEBOT_CHANGE_STATUS',
+              'CHAMA_AI_ACTION',
             ];
           } else {
-            newEvents = events;
+            newEvents = rabbitmq_events;
           }
           this.rabbitmqService.create(instance, {
             enabled: true,
@@ -231,6 +259,69 @@ export class InstanceController {
         }
       }
 
+      if (proxy) {
+        this.logger.verbose('creating proxy');
+        try {
+          this.proxyService.create(
+            instance,
+            {
+              enabled: true,
+              proxy,
+            },
+            false,
+          );
+        } catch (error) {
+          this.logger.log(error);
+        }
+      }
+
+      let sqsEvents: string[];
+
+      if (sqs_enabled) {
+        this.logger.verbose('creating sqs');
+        try {
+          let newEvents: string[] = [];
+          if (sqs_events.length === 0) {
+            newEvents = [
+              'APPLICATION_STARTUP',
+              'QRCODE_UPDATED',
+              'MESSAGES_SET',
+              'MESSAGES_UPSERT',
+              'MESSAGES_UPDATE',
+              'MESSAGES_DELETE',
+              'SEND_MESSAGE',
+              'CONTACTS_SET',
+              'CONTACTS_UPSERT',
+              'CONTACTS_UPDATE',
+              'PRESENCE_UPDATE',
+              'CHATS_SET',
+              'CHATS_UPSERT',
+              'CHATS_UPDATE',
+              'CHATS_DELETE',
+              'GROUPS_UPSERT',
+              'GROUP_UPDATE',
+              'GROUP_PARTICIPANTS_UPDATE',
+              'CONNECTION_UPDATE',
+              'CALL',
+              'NEW_JWT_TOKEN',
+              'TYPEBOT_START',
+              'TYPEBOT_CHANGE_STATUS',
+              'CHAMA_AI_ACTION',
+            ];
+          } else {
+            newEvents = sqs_events;
+          }
+          this.sqsService.create(instance, {
+            enabled: true,
+            events: newEvents,
+          });
+
+          sqsEvents = (await this.sqsService.find(instance)).events;
+        } catch (error) {
+          this.logger.log(error);
+        }
+      }
+
       if (typebot_url) {
         try {
           if (!isURL(typebot_url, { require_tld: false })) {
@@ -247,6 +338,7 @@ export class InstanceController {
             keyword_finish: typebot_keyword_finish,
             delay_message: typebot_delay_message,
             unknown_message: typebot_unknown_message,
+            listening_from_me: typebot_listening_from_me,
           });
         } catch (error) {
           this.logger.log(error);
@@ -257,7 +349,7 @@ export class InstanceController {
       const settings: wa.LocalSettings = {
         reject_call: reject_call || false,
         msg_call: msg_call || '',
-        groups_ignore: groups_ignore || false,
+        groups_ignore: groups_ignore || true,
         always_online: always_online || false,
         read_messages: read_messages || false,
         read_status: read_status || false,
@@ -280,12 +372,14 @@ export class InstanceController {
         const result = {
           instance: {
             instanceName: instance.instanceName,
+            instanceId: instanceId,
             status: 'created',
           },
           hash,
           webhook: {
             webhook,
             webhook_by_events,
+            webhook_base64,
             events: webhookEvents,
           },
           websocket: {
@@ -296,6 +390,10 @@ export class InstanceController {
             enabled: rabbitmq_enabled,
             events: rabbitmqEvents,
           },
+          sqs: {
+            enabled: sqs_enabled,
+            events: sqsEvents,
+          },
           typebot: {
             enabled: typebot_url ? true : false,
             url: typebot_url,
@@ -304,9 +402,11 @@ export class InstanceController {
             keyword_finish: typebot_keyword_finish,
             delay_message: typebot_delay_message,
             unknown_message: typebot_unknown_message,
+            listening_from_me: typebot_listening_from_me,
           },
           settings,
           qrcode: getQrcode,
+          proxy,
         };
 
         this.logger.verbose('instance created');
@@ -356,15 +456,8 @@ export class InstanceController {
           number,
           reopen_conversation: chatwoot_reopen_conversation || false,
           conversation_pending: chatwoot_conversation_pending || false,
+          auto_create: true,
         });
-
-        this.chatwootService.initInstanceChatwoot(
-          instance,
-          instance.instanceName.split('-cwId-')[0],
-          `${urlServer}/chatwoot/webhook/${encodeURIComponent(instance.instanceName)}`,
-          qrcode,
-          number,
-        );
       } catch (error) {
         this.logger.log(error);
       }
@@ -372,12 +465,14 @@ export class InstanceController {
       return {
         instance: {
           instanceName: instance.instanceName,
+          instanceId: instanceId,
           status: 'created',
         },
         hash,
         webhook: {
           webhook,
           webhook_by_events,
+          webhook_base64,
           events: webhookEvents,
         },
         websocket: {
@@ -388,6 +483,10 @@ export class InstanceController {
           enabled: rabbitmq_enabled,
           events: rabbitmqEvents,
         },
+        sqs: {
+          enabled: sqs_enabled,
+          events: sqsEvents,
+        },
         typebot: {
           enabled: typebot_url ? true : false,
           url: typebot_url,
@@ -396,6 +495,7 @@ export class InstanceController {
           keyword_finish: typebot_keyword_finish,
           delay_message: typebot_delay_message,
           unknown_message: typebot_unknown_message,
+          listening_from_me: typebot_listening_from_me,
         },
         settings,
         chatwoot: {
@@ -410,6 +510,7 @@ export class InstanceController {
           name_inbox: instance.instanceName,
           webhook_url: `${urlServer}/chatwoot/webhook/${encodeURIComponent(instance.instanceName)}`,
         },
+        proxy,
       };
     } catch (error) {
       this.logger.error(error.message[0]);
@@ -462,10 +563,19 @@ export class InstanceController {
     try {
       this.logger.verbose('requested restartInstance from ' + instanceName + ' instance');
 
-      this.logger.verbose('logging out instance: ' + instanceName);
-      this.waMonitor.waInstances[instanceName]?.client?.ws?.close();
+      const instance = this.waMonitor.waInstances[instanceName];
+      const state = instance?.connectionStatus?.state;
 
-      return { status: 'SUCCESS', error: false, response: { message: 'Instance restarted' } };
+      switch (state) {
+        case 'open':
+          this.logger.verbose('logging out instance: ' + instanceName);
+          await instance.reloadConnection();
+          await delay(2000);
+
+          return await this.connectionState({ instanceName });
+        default:
+          return await this.connectionState({ instanceName });
+      }
     } catch (error) {
       this.logger.error(error);
     }
@@ -481,13 +591,16 @@ export class InstanceController {
     };
   }
 
-  public async fetchInstances({ instanceName }: InstanceDto) {
-    this.logger.verbose('requested fetchInstances from ' + instanceName + ' instance');
+  public async fetchInstances({ instanceName, instanceId }: InstanceDto) {
     if (instanceName) {
+      this.logger.verbose('requested fetchInstances from ' + instanceName + ' instance');
       this.logger.verbose('instanceName: ' + instanceName);
       return this.waMonitor.instanceInfo(instanceName);
+    } else if (instanceId) {
+      return this.waMonitor.instanceInfoById(instanceId);
     }
 
+    this.logger.verbose('requested fetchInstances (all instances)');
     return this.waMonitor.instanceInfo();
   }
 
@@ -520,19 +633,23 @@ export class InstanceController {
       throw new BadRequestException('The "' + instanceName + '" instance needs to be disconnected');
     }
     try {
+      this.waMonitor.waInstances[instanceName]?.removeRabbitmqQueues();
+
       if (instance.state === 'connecting') {
         this.logger.verbose('logging out instance: ' + instanceName);
 
         await this.logout({ instanceName });
-        delete this.waMonitor.waInstances[instanceName];
-        return { status: 'SUCCESS', error: false, response: { message: 'Instance deleted' } };
-      } else {
-        this.logger.verbose('deleting instance: ' + instanceName);
-
-        delete this.waMonitor.waInstances[instanceName];
-        this.eventEmitter.emit('remove.instance', instanceName, 'inner');
-        return { status: 'SUCCESS', error: false, response: { message: 'Instance deleted' } };
       }
+
+      this.logger.verbose('deleting instance: ' + instanceName);
+
+      this.waMonitor.waInstances[instanceName].sendDataWebhook(Events.INSTANCE_DELETE, {
+        instanceName,
+        instanceId: (await this.repository.auth.find(instanceName))?.instanceId,
+      });
+      delete this.waMonitor.waInstances[instanceName];
+      this.eventEmitter.emit('remove.instance', instanceName, 'inner');
+      return { status: 'SUCCESS', error: false, response: { message: 'Instance deleted' } };
     } catch (error) {
       throw new BadRequestException(error.toString());
     }

src/whatsapp/controllers/rabbitmq.controller.ts

@@ -40,6 +40,9 @@ export class RabbitmqController {
         'CONNECTION_UPDATE',
         'CALL',
         'NEW_JWT_TOKEN',
+        'TYPEBOT_START',
+        'TYPEBOT_CHANGE_STATUS',
+        'CHAMA_AI_ACTION',
       ];
     }
 

src/whatsapp/controllers/settings.controller.ts

@@ -19,6 +19,7 @@ export class SettingsController {
 
   public async findSettings(instance: InstanceDto) {
     logger.verbose('requested findSettings from ' + instance.instanceName + ' instance');
-    return this.settingsService.find(instance);
+    const settings = this.settingsService.find(instance);
+    return settings;
   }
 }

src/whatsapp/controllers/sqs.controller.ts

@@ -0,0 +1,56 @@
+import { Logger } from '../../config/logger.config';
+import { InstanceDto } from '../dto/instance.dto';
+import { SqsDto } from '../dto/sqs.dto';
+import { SqsService } from '../services/sqs.service';
+
+const logger = new Logger('SqsController');
+
+export class SqsController {
+  constructor(private readonly sqsService: SqsService) {}
+
+  public async createSqs(instance: InstanceDto, data: SqsDto) {
+    logger.verbose('requested createSqs from ' + instance.instanceName + ' instance');
+
+    if (!data.enabled) {
+      logger.verbose('sqs disabled');
+      data.events = [];
+    }
+
+    if (data.events.length === 0) {
+      logger.verbose('sqs events empty');
+      data.events = [
+        'APPLICATION_STARTUP',
+        'QRCODE_UPDATED',
+        'MESSAGES_SET',
+        'MESSAGES_UPSERT',
+        'MESSAGES_UPDATE',
+        'MESSAGES_DELETE',
+        'SEND_MESSAGE',
+        'CONTACTS_SET',
+        'CONTACTS_UPSERT',
+        'CONTACTS_UPDATE',
+        'PRESENCE_UPDATE',
+        'CHATS_SET',
+        'CHATS_UPSERT',
+        'CHATS_UPDATE',
+        'CHATS_DELETE',
+        'GROUPS_UPSERT',
+        'GROUP_UPDATE',
+        'GROUP_PARTICIPANTS_UPDATE',
+        'CONNECTION_UPDATE',
+        'CALL',
+        'NEW_JWT_TOKEN',
+        'TYPEBOT_START',
+        'TYPEBOT_CHANGE_STATUS',
+        'CHAMA_AI_ACTION',
+      ];
+    }
+
+    return this.sqsService.create(instance, data);
+  }
+
+  public async findSqs(instance: InstanceDto) {
+    logger.verbose('requested findSqs from ' + instance.instanceName + ' instance');
+    return this.sqsService.find(instance);
+  }
+}

src/whatsapp/controllers/views.controller.ts

@@ -1,17 +0,0 @@
-import { Request, Response } from 'express';
-
-import { ConfigService } from '../../config/env.config';
-import { HttpStatus } from '../routers/index.router';
-import { WAMonitoringService } from '../services/monitor.service';
-
-export class ViewsController {
-  constructor(private readonly waMonit: WAMonitoringService, private readonly configService: ConfigService) {}
-
-  public async manager(request: Request, response: Response) {
-    try {
-      return response.status(HttpStatus.OK).render('manager');
-    } catch (error) {
-      console.log('ERROR: ', error);
-    }
-  }
-}

src/whatsapp/controllers/webhook.controller.ts

@@ -48,6 +48,9 @@ export class WebhookController {
         'CONNECTION_UPDATE',
         'CALL',
         'NEW_JWT_TOKEN',
+        'TYPEBOT_START',
+        'TYPEBOT_CHANGE_STATUS',
+        'CHAMA_AI_ACTION',
       ];
     }
 

src/whatsapp/controllers/websocket.controller.ts

@@ -40,6 +40,9 @@ export class WebsocketController {
         'CONNECTION_UPDATE',
         'CALL',
         'NEW_JWT_TOKEN',
+        'TYPEBOT_START',
+        'TYPEBOT_CHANGE_STATUS',
+        'CHAMA_AI_ACTION',
       ];
     }
 

src/whatsapp/dto/chamaai.dto.ts

@@ -0,0 +1,7 @@
+export class ChamaaiDto {
+  enabled: boolean;
+  url: string;
+  token: string;
+  waNumber: string;
+  answerByAudio: boolean;
+}

src/whatsapp/dto/chat.dto.ts

@@ -1,4 +1,4 @@
-import { proto, WAPrivacyOnlineValue, WAPrivacyValue, WAReadReceiptsValue } from '@whiskeysockets/baileys';
+import { proto, WAPresence, WAPrivacyOnlineValue, WAPrivacyValue, WAReadReceiptsValue } from '@whiskeysockets/baileys';
 
 export class OnWhatsAppDto {
   constructor(public readonly jid: string, public readonly exists: boolean, public readonly name?: string) {}
@@ -83,3 +83,20 @@ export class DeleteMessage {
   remoteJid: string;
   participant?: string;
 }
+export class Options {
+  delay?: number;
+  presence?: WAPresence;
+}
+class OptionsMessage {
+  options: Options;
+}
+export class Metadata extends OptionsMessage {
+  number: string;
+}
+
+export class SendPresenceDto extends Metadata {
+  options: {
+    presence: WAPresence;
+    delay: number;
+  };
+}

src/whatsapp/dto/chatwoot.dto.ts

@@ -5,7 +5,9 @@ export class ChatwootDto {
   url?: string;
   name_inbox?: string;
   sign_msg?: boolean;
+  sign_delimiter?: string;
   number?: string;
   reopen_conversation?: boolean;
   conversation_pending?: boolean;
+  auto_create?: boolean;
 }

src/whatsapp/dto/instance.dto.ts

@@ -1,10 +1,12 @@
 export class InstanceDto {
   instanceName: string;
+  instanceId?: string;
   qrcode?: boolean;
   number?: string;
   token?: string;
   webhook?: string;
   webhook_by_events?: boolean;
+  webhook_base64?: boolean;
   events?: string[];
   reject_call?: boolean;
   msg_call?: string;
@@ -22,12 +24,14 @@ export class InstanceDto {
   websocket_events?: string[];
   rabbitmq_enabled?: boolean;
   rabbitmq_events?: string[];
+  sqs_enabled?: boolean;
+  sqs_events?: string[];
   typebot_url?: string;
   typebot?: string;
   typebot_expire?: number;
   typebot_keyword_finish?: string;
   typebot_delay_message?: number;
   typebot_unknown_message?: string;
-  proxy_enabled?: boolean;
-  proxy_proxy?: string;
+  typebot_listening_from_me?: boolean;
+  proxy?: string;
 }

src/whatsapp/dto/sendMessage.dto.ts

@@ -46,9 +46,13 @@ class PollMessage {
   values: string[];
   messageSecret?: Uint8Array;
 }
+
 export class SendTextDto extends Metadata {
   textMessage: TextMessage;
 }
+export class SendPresence extends Metadata {
+  textMessage: TextMessage;
+}
 
 export class SendStatusDto extends Metadata {
   statusMessage: StatusMessage;
@@ -61,6 +65,7 @@ export class SendPollDto extends Metadata {
 export type MediaType = 'image' | 'document' | 'video' | 'audio';
 export class MediaMessage {
   mediatype: MediaType;
+  mimetype?: string;
   caption?: string;
   // for document
   fileName?: string;

src/whatsapp/dto/sqs.dto.ts

@@ -0,0 +1,4 @@
+export class SqsDto {
+  enabled: boolean;
+  events?: string[];
+}

src/whatsapp/dto/typebot.dto.ts

@@ -4,6 +4,13 @@ export class Session {
   status?: string;
   createdAt?: number;
   updateAt?: number;
+  prefilledVariables?: PrefilledVariables;
+}
+
+export class PrefilledVariables {
+  remoteJid?: string;
+  pushName?: string;
+  additionalData?: { [key: string]: any };
 }
 
 export class TypebotDto {
@@ -14,5 +21,6 @@ export class TypebotDto {
   keyword_finish?: string;
   delay_message?: number;
   unknown_message?: string;
+  listening_from_me?: boolean;
   sessions?: Session[];
 }

src/whatsapp/dto/webhook.dto.ts

@@ -3,4 +3,5 @@ export class WebhookDto {
   url?: string;
   events?: string[];
   webhook_by_events?: boolean;
+  webhook_base64?: boolean;
 }

src/whatsapp/guards/auth.guard.ts

@@ -55,7 +55,7 @@ async function jwtGuard(req: Request, res: Response, next: NextFunction) {
   }
 }
 
-async function apikey(req: Request, res: Response, next: NextFunction) {
+async function apikey(req: Request, _: Response, next: NextFunction) {
   const env = configService.get<Auth>('AUTHENTICATION').API_KEY;
   const key = req.get('apikey');
 

src/whatsapp/guards/instance.guard.ts

@@ -4,31 +4,40 @@ import { join } from 'path';
 
 import { configService, Database, Redis } from '../../config/env.config';
 import { INSTANCE_DIR } from '../../config/path.config';
-import { BadRequestException, ForbiddenException, NotFoundException } from '../../exceptions';
+import {
+  BadRequestException,
+  ForbiddenException,
+  InternalServerErrorException,
+  NotFoundException,
+} from '../../exceptions';
 import { dbserver } from '../../libs/db.connect';
 import { InstanceDto } from '../dto/instance.dto';
 import { cache, waMonitor } from '../whatsapp.module';
 
 async function getInstance(instanceName: string) {
-  const db = configService.get<Database>('DATABASE');
-  const redisConf = configService.get<Redis>('REDIS');
+  try {
+    const db = configService.get<Database>('DATABASE');
+    const redisConf = configService.get<Redis>('REDIS');
 
-  const exists = !!waMonitor.waInstances[instanceName];
+    const exists = !!waMonitor.waInstances[instanceName];
 
-  if (redisConf.ENABLED) {
-    const keyExists = await cache.keyExists();
-    return exists || keyExists;
+    if (redisConf.ENABLED) {
+      const keyExists = await cache.keyExists();
+      return exists || keyExists;
+    }
+
+    if (db.ENABLED) {
+      const collection = dbserver
+        .getClient()
+        .db(db.CONNECTION.DB_PREFIX_NAME + '-instances')
+        .collection(instanceName);
+      return exists || (await collection.find({}).toArray()).length > 0;
+    }
+
+    return exists || existsSync(join(INSTANCE_DIR, instanceName));
+  } catch (error) {
+    throw new InternalServerErrorException(error?.toString());
   }
-
-  if (db.ENABLED) {
-    const collection = dbserver
-      .getClient()
-      .db(db.CONNECTION.DB_PREFIX_NAME + '-instances')
-      .collection(instanceName);
-    return exists || (await collection.find({}).toArray()).length > 0;
-  }
-
-  return exists || existsSync(join(INSTANCE_DIR, instanceName));
 }
 
 export async function instanceExistsGuard(req: Request, _: Response, next: NextFunction) {
@@ -56,6 +65,7 @@ export async function instanceLoggedGuard(req: Request, _: Response, next: NextF
     }
 
     if (waMonitor.waInstances[instance.instanceName]) {
+      waMonitor.waInstances[instance.instanceName]?.removeRabbitmqQueues();
       delete waMonitor.waInstances[instance.instanceName];
     }
   }

src/whatsapp/models/auth.model.ts

@@ -6,12 +6,14 @@ export class AuthRaw {
   _id?: string;
   jwt?: string;
   apikey?: string;
+  instanceId?: string;
 }
 
 const authSchema = new Schema<AuthRaw>({
   _id: { type: String, _id: true },
   jwt: { type: String, minlength: 1 },
   apikey: { type: String, minlength: 1 },
+  instanceId: { type: String, minlength: 1 },
 });
 
 export const AuthModel = dbserver?.model(AuthRaw.name, authSchema, 'authentication');

src/whatsapp/models/chamaai.model.ts

@@ -0,0 +1,24 @@
+import { Schema } from 'mongoose';
+
+import { dbserver } from '../../libs/db.connect';
+
+export class ChamaaiRaw {
+  _id?: string;
+  enabled?: boolean;
+  url?: string;
+  token?: string;
+  waNumber?: string;
+  answerByAudio?: boolean;
+}
+
+const chamaaiSchema = new Schema<ChamaaiRaw>({
+  _id: { type: String, _id: true },
+  enabled: { type: Boolean, required: true },
+  url: { type: String, required: true },
+  token: { type: String, required: true },
+  waNumber: { type: String, required: true },
+  answerByAudio: { type: Boolean, required: true },
+});
+
+export const ChamaaiModel = dbserver?.model(ChamaaiRaw.name, chamaaiSchema, 'chamaai');
+export type IChamaaiModel = typeof ChamaaiModel;

src/whatsapp/models/chatwoot.model.ts

@@ -10,6 +10,7 @@ export class ChatwootRaw {
   url?: string;
   name_inbox?: string;
   sign_msg?: boolean;
+  sign_delimiter?: string;
   number?: string;
   reopen_conversation?: boolean;
   conversation_pending?: boolean;
@@ -23,7 +24,10 @@ const chatwootSchema = new Schema<ChatwootRaw>({
   url: { type: String, required: true },
   name_inbox: { type: String, required: true },
   sign_msg: { type: Boolean, required: true },
+  sign_delimiter: { type: String, required: false },
   number: { type: String, required: true },
+  reopen_conversation: { type: Boolean, required: true },
+  conversation_pending: { type: Boolean, required: true },
 });
 
 export const ChatwootModel = dbserver?.model(ChatwootRaw.name, chatwootSchema, 'chatwoot');

src/whatsapp/models/index.ts

@@ -1,4 +1,5 @@
 export * from './auth.model';
+export * from './chamaai.model';
 export * from './chat.model';
 export * from './chatwoot.model';
 export * from './contact.model';
@@ -6,6 +7,7 @@ export * from './message.model';
 export * from './proxy.model';
 export * from './rabbitmq.model';
 export * from './settings.model';
+export * from './sqs.model';
 export * from './typebot.model';
 export * from './webhook.model';
 export * from './websocket.model';

src/whatsapp/models/message.model.ts

@@ -10,6 +10,12 @@ class Key {
   participant?: string;
 }
 
+class ChatwootMessage {
+  messageId?: number;
+  inboxId?: number;
+  conversationId?: number;
+}
+
 export class MessageRaw {
   _id?: string;
   key?: Key;
@@ -20,6 +26,9 @@ export class MessageRaw {
   messageTimestamp?: number | Long.Long;
   owner: string;
   source?: 'android' | 'web' | 'ios';
+  source_id?: string;
+  source_reply_id?: string;
+  chatwoot?: ChatwootMessage;
 }
 
 const messageSchema = new Schema<MessageRaw>({
@@ -37,8 +46,18 @@ const messageSchema = new Schema<MessageRaw>({
   source: { type: String, minlength: 3, enum: ['android', 'web', 'ios'] },
   messageTimestamp: { type: Number, required: true },
   owner: { type: String, required: true, minlength: 1 },
+  chatwoot: {
+    messageId: { type: Number },
+    inboxId: { type: Number },
+    conversationId: { type: Number },
+  },
 });
 
+messageSchema.index({ 'chatwoot.messageId': 1, owner: 1 });
+messageSchema.index({ 'key.id': 1 });
+messageSchema.index({ 'key.id': 1, owner: 1 });
+messageSchema.index({ owner: 1 });
+
 export const MessageModel = dbserver?.model(MessageRaw.name, messageSchema, 'messages');
 export type IMessageModel = typeof MessageModel;
 

src/whatsapp/models/sqs.model.ts

@@ -0,0 +1,18 @@
+import { Schema } from 'mongoose';
+
+import { dbserver } from '../../libs/db.connect';
+
+export class SqsRaw {
+  _id?: string;
+  enabled?: boolean;
+  events?: string[];
+}
+
+const sqsSchema = new Schema<SqsRaw>({
+  _id: { type: String, _id: true },
+  enabled: { type: Boolean, required: true },
+  events: { type: [String], required: true },
+});
+
+export const SqsModel = dbserver?.model(SqsRaw.name, sqsSchema, 'sqs');
+export type ISqsModel = typeof SqsModel;

src/whatsapp/models/typebot.model.ts

@@ -8,6 +8,11 @@ class Session {
   status?: string;
   createdAt?: number;
   updateAt?: number;
+  prefilledVariables?: {
+    remoteJid?: string;
+    pushName?: string;
+    additionalData?: { [key: string]: any };
+  };
 }
 
 export class TypebotRaw {
@@ -19,6 +24,7 @@ export class TypebotRaw {
   keyword_finish?: string;
   delay_message?: number;
   unknown_message?: string;
+  listening_from_me?: boolean;
   sessions?: Session[];
 }
 
@@ -31,6 +37,7 @@ const typebotSchema = new Schema<TypebotRaw>({
   keyword_finish: { type: String, required: true },
   delay_message: { type: Number, required: true },
   unknown_message: { type: String, required: true },
+  listening_from_me: { type: Boolean, required: true },
   sessions: [
     {
       remoteJid: { type: String, required: true },
@@ -38,6 +45,11 @@ const typebotSchema = new Schema<TypebotRaw>({
       status: { type: String, required: true },
       createdAt: { type: Number, required: true },
       updateAt: { type: Number, required: true },
+      prefilledVariables: {
+        remoteJid: { type: String, required: false },
+        pushName: { type: String, required: false },
+        additionalData: { type: Schema.Types.Mixed, required: false },
+      },
     },
   ],
 });

src/whatsapp/models/webhook.model.ts

@@ -8,6 +8,7 @@ export class WebhookRaw {
   enabled?: boolean;
   events?: string[];
   webhook_by_events?: boolean;
+  webhook_base64?: boolean;
 }
 
 const webhookSchema = new Schema<WebhookRaw>({
@@ -16,6 +17,7 @@ const webhookSchema = new Schema<WebhookRaw>({
   enabled: { type: Boolean, required: true },
   events: { type: [String], required: true },
   webhook_by_events: { type: Boolean, required: true },
+  webhook_base64: { type: Boolean, required: true },
 });
 
 export const WebhookModel = dbserver?.model(WebhookRaw.name, webhookSchema, 'webhook');

src/whatsapp/repository/auth.repository.ts

@@ -19,6 +19,7 @@ export class AuthRepository extends Repository {
   public async create(data: AuthRaw, instance: string): Promise<IInsert> {
     try {
       this.logger.verbose('creating auth');
+
       if (this.dbSettings.ENABLED) {
         this.logger.verbose('saving auth to db');
         const insert = await this.authModel.replaceOne({ _id: instance }, { ...data }, { upsert: true });
@@ -62,4 +63,20 @@ export class AuthRepository extends Repository {
       return {};
     }
   }
+
+  public async findInstanceNameById(instanceId: string): Promise<string | null> {
+    try {
+      this.logger.verbose('finding auth by instanceId');
+      if (this.dbSettings.ENABLED) {
+        this.logger.verbose('finding auth in db');
+        const response = await this.authModel.findOne({ instanceId });
+
+        return response._id;
+      }
+
+      this.logger.verbose('finding auth in store is not supported');
+    } catch (error) {
+      return null;
+    }
+  }
 }

src/whatsapp/repository/chamaai.repository.ts

@@ -0,0 +1,62 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+import { ConfigService } from '../../config/env.config';
+import { Logger } from '../../config/logger.config';
+import { IInsert, Repository } from '../abstract/abstract.repository';
+import { ChamaaiRaw, IChamaaiModel } from '../models';
+
+export class ChamaaiRepository extends Repository {
+  constructor(private readonly chamaaiModel: IChamaaiModel, private readonly configService: ConfigService) {
+    super(configService);
+  }
+
+  private readonly logger = new Logger('ChamaaiRepository');
+
+  public async create(data: ChamaaiRaw, instance: string): Promise<IInsert> {
+    try {
+      this.logger.verbose('creating chamaai');
+      if (this.dbSettings.ENABLED) {
+        this.logger.verbose('saving chamaai to db');
+        const insert = await this.chamaaiModel.replaceOne({ _id: instance }, { ...data }, { upsert: true });
+
+        this.logger.verbose('chamaai saved to db: ' + insert.modifiedCount + ' chamaai');
+        return { insertCount: insert.modifiedCount };
+      }
+
+      this.logger.verbose('saving chamaai to store');
+
+      this.writeStore<ChamaaiRaw>({
+        path: join(this.storePath, 'chamaai'),
+        fileName: instance,
+        data,
+      });
+
+      this.logger.verbose('chamaai saved to store in path: ' + join(this.storePath, 'chamaai') + '/' + instance);
+
+      this.logger.verbose('chamaai created');
+      return { insertCount: 1 };
+    } catch (error) {
+      return error;
+    }
+  }
+
+  public async find(instance: string): Promise<ChamaaiRaw> {
+    try {
+      this.logger.verbose('finding chamaai');
+      if (this.dbSettings.ENABLED) {
+        this.logger.verbose('finding chamaai in db');
+        return await this.chamaaiModel.findOne({ _id: instance });
+      }
+
+      this.logger.verbose('finding chamaai in store');
+      return JSON.parse(
+        readFileSync(join(this.storePath, 'chamaai', instance + '.json'), {
+          encoding: 'utf-8',
+        }),
+      ) as ChamaaiRaw;
+    } catch (error) {
+      return {};
+    }
+  }
+}

src/whatsapp/repository/message.repository.ts

@@ -91,11 +91,13 @@ export class MessageRepository extends Repository {
       this.logger.verbose('finding messages');
       if (this.dbSettings.ENABLED) {
         this.logger.verbose('finding messages in db');
-        if (query?.where?.key) {
-          for (const [k, v] of Object.entries(query.where.key)) {
-            query.where['key.' + k] = v;
+        for (const [o, p] of Object.entries(query?.where)) {
+          if (typeof p === 'object' && p !== null && !Array.isArray(p)) {
+            for (const [k, v] of Object.entries(p)) {
+              query.where[`${o}.${k}`] = v;
+            }
+            delete query.where[o];
           }
-          delete query?.where?.key;
         }
 
         return await this.messageModel
@@ -144,4 +146,55 @@ export class MessageRepository extends Repository {
       return [];
     }
   }
+
+  public async update(data: MessageRaw[], instanceName: string, saveDb?: boolean): Promise<IInsert> {
+    try {
+      if (this.dbSettings.ENABLED && saveDb) {
+        this.logger.verbose('updating messages in db');
+
+        const messages = data.map((message) => {
+          return {
+            updateOne: {
+              filter: { 'key.id': message.key.id },
+              update: { ...message },
+            },
+          };
+        });
+
+        const { nModified } = await this.messageModel.bulkWrite(messages);
+
+        this.logger.verbose('messages updated in db: ' + nModified + ' messages');
+        return { insertCount: nModified };
+      }
+
+      this.logger.verbose('updating messages in store');
+
+      const store = this.configService.get<StoreConf>('STORE');
+
+      if (store.MESSAGES) {
+        this.logger.verbose('updating messages in store');
+        data.forEach((message) => {
+          this.writeStore({
+            path: join(this.storePath, 'messages', instanceName),
+            fileName: message.key.id,
+            data: message,
+          });
+          this.logger.verbose(
+            'messages updated in store in path: ' +
+              join(this.storePath, 'messages', instanceName) +
+              '/' +
+              message.key.id,
+          );
+        });
+
+        this.logger.verbose('messages updated in store: ' + data.length + ' messages');
+        return { insertCount: data.length };
+      }
+
+      this.logger.verbose('messages not updated');
+      return { insertCount: 0 };
+    } catch (error) {
+      this.logger.error(error);
+    }
+  }
 }

src/whatsapp/repository/repository.manager.ts

@@ -5,6 +5,7 @@ import { join } from 'path';
 import { Auth, ConfigService, Database } from '../../config/env.config';
 import { Logger } from '../../config/logger.config';
 import { AuthRepository } from './auth.repository';
+import { ChamaaiRepository } from './chamaai.repository';
 import { ChatRepository } from './chat.repository';
 import { ChatwootRepository } from './chatwoot.repository';
 import { ContactRepository } from './contact.repository';
@@ -13,6 +14,7 @@ import { MessageUpRepository } from './messageUp.repository';
 import { ProxyRepository } from './proxy.repository';
 import { RabbitmqRepository } from './rabbitmq.repository';
 import { SettingsRepository } from './settings.repository';
+import { SqsRepository } from './sqs.repository';
 import { TypebotRepository } from './typebot.repository';
 import { WebhookRepository } from './webhook.repository';
 import { WebsocketRepository } from './websocket.repository';
@@ -27,8 +29,10 @@ export class RepositoryBroker {
     public readonly settings: SettingsRepository,
     public readonly websocket: WebsocketRepository,
     public readonly rabbitmq: RabbitmqRepository,
+    public readonly sqs: SqsRepository,
     public readonly typebot: TypebotRepository,
     public readonly proxy: ProxyRepository,
+    public readonly chamaai: ChamaaiRepository,
     public readonly auth: AuthRepository,
     private configService: ConfigService,
     dbServer?: MongoClient,
@@ -61,8 +65,10 @@ export class RepositoryBroker {
         const settingsDir = join(storePath, 'settings');
         const websocketDir = join(storePath, 'websocket');
         const rabbitmqDir = join(storePath, 'rabbitmq');
+        const sqsDir = join(storePath, 'sqs');
         const typebotDir = join(storePath, 'typebot');
         const proxyDir = join(storePath, 'proxy');
+        const chamaaiDir = join(storePath, 'chamaai');
         const tempDir = join(storePath, 'temp');
 
         if (!fs.existsSync(authDir)) {
@@ -105,6 +111,10 @@ export class RepositoryBroker {
           this.logger.verbose('creating rabbitmq dir: ' + rabbitmqDir);
           fs.mkdirSync(rabbitmqDir, { recursive: true });
         }
+        if (!fs.existsSync(sqsDir)) {
+          this.logger.verbose('creating sqs dir: ' + sqsDir);
+          fs.mkdirSync(sqsDir, { recursive: true });
+        }
         if (!fs.existsSync(typebotDir)) {
           this.logger.verbose('creating typebot dir: ' + typebotDir);
           fs.mkdirSync(typebotDir, { recursive: true });
@@ -113,6 +123,10 @@ export class RepositoryBroker {
           this.logger.verbose('creating proxy dir: ' + proxyDir);
           fs.mkdirSync(proxyDir, { recursive: true });
         }
+        if (!fs.existsSync(chamaaiDir)) {
+          this.logger.verbose('creating chamaai dir: ' + chamaaiDir);
+          fs.mkdirSync(chamaaiDir, { recursive: true });
+        }
         if (!fs.existsSync(tempDir)) {
           this.logger.verbose('creating temp dir: ' + tempDir);
           fs.mkdirSync(tempDir, { recursive: true });

src/whatsapp/repository/sqs.repository.ts

@@ -0,0 +1,62 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+import { ConfigService } from '../../config/env.config';
+import { Logger } from '../../config/logger.config';
+import { IInsert, Repository } from '../abstract/abstract.repository';
+import { ISqsModel, SqsRaw } from '../models';
+
+export class SqsRepository extends Repository {
+  constructor(private readonly sqsModel: ISqsModel, private readonly configService: ConfigService) {
+    super(configService);
+  }
+
+  private readonly logger = new Logger('SqsRepository');
+
+  public async create(data: SqsRaw, instance: string): Promise<IInsert> {
+    try {
+      this.logger.verbose('creating sqs');
+      if (this.dbSettings.ENABLED) {
+        this.logger.verbose('saving sqs to db');
+        const insert = await this.sqsModel.replaceOne({ _id: instance }, { ...data }, { upsert: true });
+
+        this.logger.verbose('sqs saved to db: ' + insert.modifiedCount + ' sqs');
+        return { insertCount: insert.modifiedCount };
+      }
+
+      this.logger.verbose('saving sqs to store');
+
+      this.writeStore<SqsRaw>({
+        path: join(this.storePath, 'sqs'),
+        fileName: instance,
+        data,
+      });
+
+      this.logger.verbose('sqs saved to store in path: ' + join(this.storePath, 'sqs') + '/' + instance);
+
+      this.logger.verbose('sqs created');
+      return { insertCount: 1 };
+    } catch (error) {
+      return error;
+    }
+  }
+
+  public async find(instance: string): Promise<SqsRaw> {
+    try {
+      this.logger.verbose('finding sqs');
+      if (this.dbSettings.ENABLED) {
+        this.logger.verbose('finding sqs in db');
+        return await this.sqsModel.findOne({ _id: instance });
+      }
+
+      this.logger.verbose('finding sqs in store');
+      return JSON.parse(
+        readFileSync(join(this.storePath, 'sqs', instance + '.json'), {
+          encoding: 'utf-8',
+        }),
+      ) as SqsRaw;
+    } catch (error) {
+      return {};
+    }
+  }
+}

src/whatsapp/routers/chamaai.router.ts

@@ -0,0 +1,52 @@
+import { RequestHandler, Router } from 'express';
+
+import { Logger } from '../../config/logger.config';
+import { chamaaiSchema, instanceNameSchema } from '../../validate/validate.schema';
+import { RouterBroker } from '../abstract/abstract.router';
+import { ChamaaiDto } from '../dto/chamaai.dto';
+import { InstanceDto } from '../dto/instance.dto';
+import { chamaaiController } from '../whatsapp.module';
+import { HttpStatus } from './index.router';
+
+const logger = new Logger('ChamaaiRouter');
+
+export class ChamaaiRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('set'), ...guards, async (req, res) => {
+        logger.verbose('request received in setChamaai');
+        logger.verbose('request body: ');
+        logger.verbose(req.body);
+
+        logger.verbose('request query: ');
+        logger.verbose(req.query);
+        const response = await this.dataValidate<ChamaaiDto>({
+          request: req,
+          schema: chamaaiSchema,
+          ClassRef: ChamaaiDto,
+          execute: (instance, data) => chamaaiController.createChamaai(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .get(this.routerPath('find'), ...guards, async (req, res) => {
+        logger.verbose('request received in findChamaai');
+        logger.verbose('request body: ');
+        logger.verbose(req.body);
+
+        logger.verbose('request query: ');
+        logger.verbose(req.query);
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceNameSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => chamaaiController.findChamaai(instance),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router = Router();
+}

src/whatsapp/routers/chat.router.ts

@@ -7,6 +7,7 @@ import {
   deleteMessageSchema,
   messageUpSchema,
   messageValidateSchema,
+  presenceSchema,
   privacySettingsSchema,
   profileNameSchema,
   profilePictureSchema,
@@ -26,6 +27,7 @@ import {
   ProfilePictureDto,
   ProfileStatusDto,
   ReadMessageDto,
+  SendPresenceDto,
   WhatsAppNumberDto,
 } from '../dto/chat.dto';
 import { InstanceDto } from '../dto/instance.dto';
@@ -228,6 +230,22 @@ export class ChatRouter extends RouterBroker {
 
         return res.status(HttpStatus.OK).json(response);
       })
+      .post(this.routerPath('sendPresence'), ...guards, async (req, res) => {
+        logger.verbose('request received in sendPresence');
+        logger.verbose('request body: ');
+        logger.verbose(req.body);
+
+        logger.verbose('request query: ');
+        logger.verbose(req.query);
+        const response = await this.dataValidate<null>({
+          request: req,
+          schema: presenceSchema,
+          ClassRef: SendPresenceDto,
+          execute: (instance, data) => chatController.sendPresence(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
       // Profile routes
       .get(this.routerPath('fetchPrivacySettings'), ...guards, async (req, res) => {
         logger.verbose('request received in fetchPrivacySettings');

src/whatsapp/routers/index.router.ts

@@ -4,6 +4,7 @@ import fs from 'fs';
 import { Auth, configService } from '../../config/env.config';
 import { authGuard } from '../guards/auth.guard';
 import { instanceExistsGuard, instanceLoggedGuard } from '../guards/instance.guard';
+import { ChamaaiRouter } from './chamaai.router';
 import { ChatRouter } from './chat.router';
 import { ChatwootRouter } from './chatwoot.router';
 import { GroupRouter } from './group.router';
@@ -12,6 +13,7 @@ import { ProxyRouter } from './proxy.router';
 import { RabbitmqRouter } from './rabbitmq.router';
 import { MessageRouter } from './sendMessage.router';
 import { SettingsRouter } from './settings.router';
+import { SqsRouter } from './sqs.router';
 import { TypebotRouter } from './typebot.router';
 import { ViewsRouter } from './view.router';
 import { WebhookRouter } from './webhook.router';
@@ -29,20 +31,25 @@ enum HttpStatus {
 
 const router = Router();
 const authType = configService.get<Auth>('AUTHENTICATION').TYPE;
+const serverConfig = configService.get('SERVER');
 const guards = [instanceExistsGuard, instanceLoggedGuard, authGuard[authType]];
 
 const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
 
+if (!serverConfig.DISABLE_MANAGER) router.use('/manager', new ViewsRouter().router);
+
 router
   .get('/', (req, res) => {
     res.status(HttpStatus.OK).json({
       status: HttpStatus.OK,
       message: 'Welcome to the Evolution API, it is working!',
       version: packageJson.version,
+      swagger: !serverConfig.DISABLE_DOCS ? `${req.protocol}://${req.get('host')}/docs` : undefined,
+      manager: !serverConfig.DISABLE_MANAGER ? `${req.protocol}://${req.get('host')}/manager` : undefined,
+      documentation: `https://doc.evolution-api.com`,
     });
   })
   .use('/instance', new InstanceRouter(configService, ...guards).router)
-  .use('/manager', new ViewsRouter().router)
   .use('/message', new MessageRouter(...guards).router)
   .use('/chat', new ChatRouter(...guards).router)
   .use('/group', new GroupRouter(...guards).router)
@@ -51,7 +58,9 @@ router
   .use('/settings', new SettingsRouter(...guards).router)
   .use('/websocket', new WebsocketRouter(...guards).router)
   .use('/rabbitmq', new RabbitmqRouter(...guards).router)
+  .use('/sqs', new SqsRouter(...guards).router)
   .use('/typebot', new TypebotRouter(...guards).router)
-  .use('/proxy', new ProxyRouter(...guards).router);
+  .use('/proxy', new ProxyRouter(...guards).router)
+  .use('/chamaai', new ChamaaiRouter(...guards).router);
 
 export { HttpStatus, router };

src/whatsapp/routers/sqs.router.ts

@@ -0,0 +1,52 @@
+import { RequestHandler, Router } from 'express';
+
+import { Logger } from '../../config/logger.config';
+import { instanceNameSchema, sqsSchema } from '../../validate/validate.schema';
+import { RouterBroker } from '../abstract/abstract.router';
+import { InstanceDto } from '../dto/instance.dto';
+import { SqsDto } from '../dto/sqs.dto';
+import { sqsController } from '../whatsapp.module';
+import { HttpStatus } from './index.router';
+
+const logger = new Logger('SqsRouter');
+
+export class SqsRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('set'), ...guards, async (req, res) => {
+        logger.verbose('request received in setSqs');
+        logger.verbose('request body: ');
+        logger.verbose(req.body);
+
+        logger.verbose('request query: ');
+        logger.verbose(req.query);
+        const response = await this.dataValidate<SqsDto>({
+          request: req,
+          schema: sqsSchema,
+          ClassRef: SqsDto,
+          execute: (instance, data) => sqsController.createSqs(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .get(this.routerPath('find'), ...guards, async (req, res) => {
+        logger.verbose('request received in findSqs');
+        logger.verbose('request body: ');
+        logger.verbose(req.body);
+
+        logger.verbose('request query: ');
+        logger.verbose(req.query);
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceNameSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => sqsController.findSqs(instance),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router = Router();
+}

src/whatsapp/routers/view.router.ts

@@ -1,14 +1,32 @@
 import { Router } from 'express';
+import fs from 'fs';
+import mime from 'mime-types';
 
 import { RouterBroker } from '../abstract/abstract.router';
-import { viewsController } from '../whatsapp.module';
 
 export class ViewsRouter extends RouterBroker {
   constructor() {
     super();
 
-    this.router.get('/', (req, res) => {
-      return viewsController.manager(req, res);
+    const basePath = 'evolution-manager/dist';
+
+    const indexPath = require.resolve(`${basePath}/index.html`);
+
+    this.router.get('/*', (req, res) => {
+      try {
+        const pathname = req.url.split('?')[0];
+
+        // verify if url is a file in dist folder
+        if (pathname === '/') throw {};
+        const filePath = require.resolve(`${basePath}${pathname}`);
+
+        const contentType = mime.lookup(filePath) || 'text/plain';
+        res.set('Content-Type', contentType);
+        res.end(fs.readFileSync(filePath));
+      } catch {
+        res.set('Content-Type', 'text/html');
+        res.send(fs.readFileSync(indexPath));
+      }
     });
   }
 

src/whatsapp/services/auth.service.ts

@@ -46,7 +46,10 @@ export class AuthService {
 
     this.logger.verbose('JWT token created: ' + token);
 
-    const auth = await this.repository.auth.create({ jwt: token }, instance.instanceName);
+    const auth = await this.repository.auth.create(
+      { jwt: token, instanceId: instance.instanceId },
+      instance.instanceName,
+    );
 
     this.logger.verbose('JWT token saved in database');
 
@@ -66,7 +69,7 @@ export class AuthService {
 
     this.logger.verbose(token ? 'APIKEY defined: ' + apikey : 'APIKEY created: ' + apikey);
 
-    const auth = await this.repository.auth.create({ apikey }, instance.instanceName);
+    const auth = await this.repository.auth.create({ apikey, instanceId: instance.instanceId }, instance.instanceName);
 
     this.logger.verbose('APIKEY saved in database');
 

src/whatsapp/services/chamaai.service.ts

@@ -0,0 +1,230 @@
+import axios from 'axios';
+import { writeFileSync } from 'fs';
+import path from 'path';
+
+import { ConfigService, HttpServer } from '../../config/env.config';
+import { Logger } from '../../config/logger.config';
+import { ChamaaiDto } from '../dto/chamaai.dto';
+import { InstanceDto } from '../dto/instance.dto';
+import { ChamaaiRaw } from '../models';
+import { Events } from '../types/wa.types';
+import { WAMonitoringService } from './monitor.service';
+
+export class ChamaaiService {
+  constructor(private readonly waMonitor: WAMonitoringService, private readonly configService: ConfigService) {}
+
+  private readonly logger = new Logger(ChamaaiService.name);
+
+  public create(instance: InstanceDto, data: ChamaaiDto) {
+    this.logger.verbose('create chamaai: ' + instance.instanceName);
+    this.waMonitor.waInstances[instance.instanceName].setChamaai(data);
+
+    return { chamaai: { ...instance, chamaai: data } };
+  }
+
+  public async find(instance: InstanceDto): Promise<ChamaaiRaw> {
+    try {
+      this.logger.verbose('find chamaai: ' + instance.instanceName);
+      const result = await this.waMonitor.waInstances[instance.instanceName].findChamaai();
+
+      if (Object.keys(result).length === 0) {
+        throw new Error('Chamaai not found');
+      }
+
+      return result;
+    } catch (error) {
+      return { enabled: false, url: '', token: '', waNumber: '', answerByAudio: false };
+    }
+  }
+
+  private getTypeMessage(msg: any) {
+    this.logger.verbose('get type message');
+
+    const types = {
+      conversation: msg.conversation,
+      extendedTextMessage: msg.extendedTextMessage?.text,
+    };
+
+    this.logger.verbose('type message: ' + types);
+
+    return types;
+  }
+
+  private getMessageContent(types: any) {
+    this.logger.verbose('get message content');
+    const typeKey = Object.keys(types).find((key) => types[key] !== undefined);
+
+    const result = typeKey ? types[typeKey] : undefined;
+
+    this.logger.verbose('message content: ' + result);
+
+    return result;
+  }
+
+  private getConversationMessage(msg: any) {
+    this.logger.verbose('get conversation message');
+
+    const types = this.getTypeMessage(msg);
+
+    const messageContent = this.getMessageContent(types);
+
+    this.logger.verbose('conversation message: ' + messageContent);
+
+    return messageContent;
+  }
+
+  private calculateTypingTime(text: string) {
+    const wordsPerMinute = 100;
+
+    const wordCount = text.split(' ').length;
+    const typingTimeInMinutes = wordCount / wordsPerMinute;
+    const typingTimeInMilliseconds = typingTimeInMinutes * 60;
+    return typingTimeInMilliseconds;
+  }
+
+  private convertToMilliseconds(count: number) {
+    const averageCharactersPerSecond = 15;
+    const characterCount = count;
+    const speakingTimeInSeconds = characterCount / averageCharactersPerSecond;
+    return speakingTimeInSeconds;
+  }
+
+  private getRegexPatterns() {
+    const patternsToCheck = [
+      '.*atend.*humano.*',
+      '.*falar.*com.*um.*humano.*',
+      '.*fala.*humano.*',
+      '.*atend.*humano.*',
+      '.*fala.*atend.*',
+      '.*preciso.*ajuda.*',
+      '.*quero.*suporte.*',
+      '.*preciso.*assiste.*',
+      '.*ajuda.*atend.*',
+      '.*chama.*atendente.*',
+      '.*suporte.*urgente.*',
+      '.*atend.*por.*favor.*',
+      '.*quero.*falar.*com.*alguém.*',
+      '.*falar.*com.*um.*humano.*',
+      '.*transfer.*humano.*',
+      '.*transfer.*atend.*',
+      '.*equipe.*humano.*',
+      '.*suporte.*humano.*',
+    ];
+
+    const regexPatterns = patternsToCheck.map((pattern) => new RegExp(pattern, 'iu'));
+    return regexPatterns;
+  }
+
+  public async sendChamaai(instance: InstanceDto, remoteJid: string, msg: any) {
+    const content = this.getConversationMessage(msg.message);
+    const msgType = msg.messageType;
+    const find = await this.find(instance);
+    const url = find.url;
+    const token = find.token;
+    const waNumber = find.waNumber;
+    const answerByAudio = find.answerByAudio;
+
+    if (!content && msgType !== 'audioMessage') {
+      return;
+    }
+
+    let data;
+    let endpoint;
+
+    if (msgType === 'audioMessage') {
+      const downloadBase64 = await this.waMonitor.waInstances[instance.instanceName].getBase64FromMediaMessage({
+        message: {
+          ...msg,
+        },
+      });
+
+      const random = Math.random().toString(36).substring(7);
+      const nameFile = `${random}.ogg`;
+
+      const fileData = Buffer.from(downloadBase64.base64, 'base64');
+
+      const fileName = `${path.join(
+        this.waMonitor.waInstances[instance.instanceName].storePath,
+        'temp',
+        `${nameFile}`,
+      )}`;
+
+      writeFileSync(fileName, fileData, 'utf8');
+
+      const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+
+      const url = `${urlServer}/store/temp/${nameFile}`;
+
+      data = {
+        waNumber: waNumber,
+        audioUrl: url,
+        queryNumber: remoteJid.split('@')[0],
+        answerByAudio: answerByAudio,
+      };
+      endpoint = 'processMessageAudio';
+    } else {
+      data = {
+        waNumber: waNumber,
+        question: content,
+        queryNumber: remoteJid.split('@')[0],
+        answerByAudio: answerByAudio,
+      };
+      endpoint = 'processMessageText';
+    }
+
+    const request = await axios.post(`${url}/${endpoint}`, data, {
+      headers: {
+        Authorization: `${token}`,
+      },
+    });
+
+    const answer = request.data?.answer;
+
+    const type = request.data?.type;
+
+    const characterCount = request.data?.characterCount;
+
+    if (answer) {
+      if (type === 'text') {
+        this.waMonitor.waInstances[instance.instanceName].textMessage({
+          number: remoteJid.split('@')[0],
+          options: {
+            delay: this.calculateTypingTime(answer) * 1000 || 1000,
+            presence: 'composing',
+            linkPreview: false,
+            quoted: {
+              key: msg.key,
+              message: msg.message,
+            },
+          },
+          textMessage: {
+            text: answer,
+          },
+        });
+      }
+
+      if (type === 'audio') {
+        this.waMonitor.waInstances[instance.instanceName].audioWhatsapp({
+          number: remoteJid.split('@')[0],
+          options: {
+            delay: characterCount ? this.convertToMilliseconds(characterCount) * 1000 || 1000 : 1000,
+            presence: 'recording',
+            encoding: true,
+          },
+          audioMessage: {
+            audio: answer,
+          },
+        });
+      }
+
+      if (this.getRegexPatterns().some((pattern) => pattern.test(answer))) {
+        this.waMonitor.waInstances[instance.instanceName].sendDataWebhook(Events.CHAMA_AI_ACTION, {
+          remoteJid: remoteJid,
+          message: msg,
+          answer: answer,
+          action: 'transfer',
+        });
+      }
+    }
+  }
+}

src/whatsapp/services/chatwoot.service.ts

@@ -2,15 +2,19 @@ import ChatwootClient from '@figuro/chatwoot-sdk';
 import axios from 'axios';
 import FormData from 'form-data';
 import { createReadStream, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import Jimp from 'jimp';
 import mimeTypes from 'mime-types';
 import path from 'path';
 
-import { ConfigService } from '../../config/env.config';
+import { ConfigService, HttpServer } from '../../config/env.config';
 import { Logger } from '../../config/logger.config';
 import { ROOT_DIR } from '../../config/path.config';
 import { ChatwootDto } from '../dto/chatwoot.dto';
 import { InstanceDto } from '../dto/instance.dto';
-import { SendAudioDto, SendMediaDto, SendTextDto } from '../dto/sendMessage.dto';
+import { Options, Quoted, SendAudioDto, SendMediaDto, SendTextDto } from '../dto/sendMessage.dto';
+import { MessageRaw } from '../models';
+import { RepositoryBroker } from '../repository/repository.manager';
+import { Events } from '../types/wa.types';
 import { WAMonitoringService } from './monitor.service';
 
 export class ChatwootService {
@@ -21,7 +25,11 @@ export class ChatwootService {
 
   private provider: any;
 
-  constructor(private readonly waMonitor: WAMonitoringService, private readonly configService: ConfigService) {
+  constructor(
+    private readonly waMonitor: WAMonitoringService,
+    private readonly configService: ConfigService,
+    private readonly repository: RepositoryBroker,
+  ) {
     this.messageCache = new Set();
   }
 
@@ -51,25 +59,26 @@ export class ChatwootService {
 
   private async getProvider(instance: InstanceDto) {
     this.logger.verbose('get provider to instance: ' + instance.instanceName);
-    try {
-      const provider = await this.waMonitor.waInstances[instance.instanceName].findChatwoot();
+    const provider = await this.waMonitor.waInstances[instance.instanceName]?.findChatwoot();
 
-      if (!provider) {
-        this.logger.warn('provider not found');
-        return null;
-      }
-
-      this.logger.verbose('provider found');
-
-      return provider;
-    } catch (error) {
-      this.logger.error('provider not found');
+    if (!provider) {
+      this.logger.warn('provider not found');
       return null;
     }
+
+    this.logger.verbose('provider found');
+
+    return provider;
+    // try {
+    // } catch (error) {
+    //   this.logger.error('provider not found');
+    //   return null;
+    // }
   }
 
   private async clientCw(instance: InstanceDto) {
     this.logger.verbose('get client to instance: ' + instance.instanceName);
+
     const provider = await this.getProvider(instance);
 
     if (!provider) {
@@ -96,11 +105,24 @@ export class ChatwootService {
     return client;
   }
 
-  public create(instance: InstanceDto, data: ChatwootDto) {
+  public async create(instance: InstanceDto, data: ChatwootDto) {
     this.logger.verbose('create chatwoot: ' + instance.instanceName);
-    this.waMonitor.waInstances[instance.instanceName].setChatwoot(data);
+
+    await this.waMonitor.waInstances[instance.instanceName].setChatwoot(data);
 
     this.logger.verbose('chatwoot created');
+
+    if (data.auto_create) {
+      const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+
+      await this.initInstanceChatwoot(
+        instance,
+        instance.instanceName.split('-cwId-')[0],
+        `${urlServer}/chatwoot/webhook/${encodeURIComponent(instance.instanceName)}`,
+        true,
+        data.number,
+      );
+    }
     return data;
   }
 
@@ -228,10 +250,6 @@ export class ChatwootService {
         inbox_id: inboxId.toString(),
       };
 
-      if (this.provider.conversation_pending) {
-        data['status'] = 'pending';
-      }
-
       const conversation = await client.conversations.create({
         accountId: this.provider.account_id,
         data,
@@ -337,14 +355,18 @@ export class ChatwootService {
     }
 
     this.logger.verbose('update contact in chatwoot');
-    const contact = await client.contacts.update({
-      accountId: this.provider.account_id,
-      id,
-      data,
-    });
+    try {
+      const contact = await client.contacts.update({
+        accountId: this.provider.account_id,
+        id,
+        data,
+      });
 
-    this.logger.verbose('contact updated');
-    return contact;
+      this.logger.verbose('contact updated');
+      return contact;
+    } catch (error) {
+      this.logger.error(error);
+    }
   }
 
   public async findContact(instance: InstanceDto, phoneNumber: string) {
@@ -460,7 +482,9 @@ export class ChatwootService {
       let contact: any;
       if (body.key.fromMe) {
         if (findContact) {
-          contact = findContact;
+          contact = await this.updateContact(instance, findContact.id, {
+            avatar_url: picture_url.profilePictureUrl || null,
+          });
         } else {
           const jid = isGroup ? null : body.key.remoteJid;
           contact = await this.createContact(
@@ -481,7 +505,12 @@ export class ChatwootService {
               avatar_url: picture_url.profilePictureUrl || null,
             });
           } else {
-            contact = findContact;
+            contact = await this.updateContact(instance, findContact.id, {
+              avatar_url: picture_url.profilePictureUrl || null,
+            });
+          }
+          if (!contact) {
+            contact = await this.findContact(instance, chatId);
           }
         } else {
           const jid = isGroup ? null : body.key.remoteJid;
@@ -614,6 +643,7 @@ export class ChatwootService {
       encoding: string;
       filename: string;
     }[],
+    messageBody?: any,
   ) {
     this.logger.verbose('create message to instance: ' + instance.instanceName);
 
@@ -624,6 +654,8 @@ export class ChatwootService {
       return null;
     }
 
+    const replyToIds = await this.getReplyToIds(messageBody, instance);
+
     this.logger.verbose('create message in chatwoot');
     const message = await client.messages.create({
       accountId: this.provider.account_id,
@@ -633,6 +665,9 @@ export class ChatwootService {
         message_type: messageType,
         attachments: attachments,
         private: privateMessage || false,
+        content_attributes: {
+          ...replyToIds,
+        },
       },
     });
 
@@ -728,6 +763,8 @@ export class ChatwootService {
     file: string,
     messageType: 'incoming' | 'outgoing' | undefined,
     content?: string,
+    instance?: InstanceDto,
+    messageBody?: any,
   ) {
     this.logger.verbose('send data to chatwoot');
 
@@ -744,6 +781,16 @@ export class ChatwootService {
     this.logger.verbose('temp file found');
     data.append('attachments[]', createReadStream(file));
 
+    if (messageBody && instance) {
+      const replyToIds = await this.getReplyToIds(messageBody, instance);
+
+      if (replyToIds.in_reply_to || replyToIds.in_reply_to_external_id) {
+        data.append('content_attributes', {
+          ...replyToIds,
+        });
+      }
+    }
+
     this.logger.verbose('get client to instance: ' + this.provider.instanceName);
     const config = {
       method: 'post',
@@ -864,7 +911,7 @@ export class ChatwootService {
     }
   }
 
-  public async sendAttachment(waInstance: any, number: string, media: any, caption?: string) {
+  public async sendAttachment(waInstance: any, number: string, media: any, caption?: string, options?: Options) {
     this.logger.verbose('send attachment to instance: ' + waInstance.instanceName);
 
     try {
@@ -874,7 +921,11 @@ export class ChatwootService {
       const fileName = decodeURIComponent(parts[parts.length - 1]);
       this.logger.verbose('file name: ' + fileName);
 
-      const mimeType = mimeTypes.lookup(fileName).toString();
+      const response = await axios.get(media, {
+        responseType: 'arraybuffer',
+      });
+
+      const mimeType = response.headers['content-type'];
       this.logger.verbose('mime type: ' + mimeType);
 
       let type = 'document';
@@ -906,13 +957,14 @@ export class ChatwootService {
           options: {
             delay: 1200,
             presence: 'recording',
+            ...options,
           },
         };
 
-        await waInstance?.audioWhatsapp(data);
+        const messageSent = await waInstance?.audioWhatsapp(data, true);
 
         this.logger.verbose('audio sent');
-        return;
+        return messageSent;
       }
 
       this.logger.verbose('send media to instance: ' + waInstance.instanceName);
@@ -926,6 +978,7 @@ export class ChatwootService {
         options: {
           delay: 1200,
           presence: 'composing',
+          ...options,
         },
       };
 
@@ -934,10 +987,10 @@ export class ChatwootService {
         data.mediaMessage.caption = caption;
       }
 
-      await waInstance?.mediaMessage(data);
+      const messageSent = await waInstance?.mediaMessage(data, true);
 
       this.logger.verbose('media sent');
-      return;
+      return messageSent;
     } catch (error) {
       this.logger.error(error);
     }
@@ -945,6 +998,8 @@ export class ChatwootService {
 
   public async receiveWebhook(instance: InstanceDto, body: any) {
     try {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
       this.logger.verbose('receive webhook to chatwoot instance: ' + instance.instanceName);
       const client = await this.clientCw(instance);
 
@@ -954,15 +1009,46 @@ export class ChatwootService {
       }
 
       this.logger.verbose('check if is bot');
-      if (!body?.conversation || body.private || body.event === 'message_updated') return { message: 'bot' };
+      if (
+        !body?.conversation ||
+        body.private ||
+        (body.event === 'message_updated' && !body.content_attributes?.deleted)
+      ) {
+        return { message: 'bot' };
+      }
 
       this.logger.verbose('check if is group');
       const chatId =
         body.conversation.meta.sender?.phone_number?.replace('+', '') || body.conversation.meta.sender?.identifier;
-      const messageReceived = body.content;
-      const senderName = body?.sender?.name;
+      // Chatwoot to Whatsapp
+      const messageReceived = body.content
+        ? body.content
+            .replaceAll(/(?<!\*)\*((?!\s)([^\n*]+?)(?<!\s))\*(?!\*)/g, '_$1_') // Substitui * por _
+            .replaceAll(/\*{2}((?!\s)([^\n*]+?)(?<!\s))\*{2}/g, '*$1*') // Substitui ** por *
+            .replaceAll(/~{2}((?!\s)([^\n*]+?)(?<!\s))~{2}/g, '~$1~') // Substitui ~~ por ~
+            .replaceAll(/(?<!`)`((?!\s)([^`*]+?)(?<!\s))`(?!`)/g, '```$1```') // Substitui ` por ```
+        : body.content;
+
+      const senderName = body?.sender?.available_name || body?.sender?.name;
       const waInstance = this.waMonitor.waInstances[instance.instanceName];
 
+      this.logger.verbose('check if is a message deletion');
+      if (body.event === 'message_updated' && body.content_attributes?.deleted) {
+        const message = await this.repository.message.find({
+          where: {
+            owner: instance.instanceName,
+            chatwoot: {
+              messageId: body.id,
+            },
+          },
+          limit: 1,
+        });
+        if (message.length && message[0].key?.id) {
+          await waInstance?.client.sendMessage(message[0].key.remoteJid, { delete: message[0].key });
+        }
+        return { message: 'bot' };
+      }
+
       if (chatId === '123456' && body.message_type === 'outgoing') {
         this.logger.verbose('check if is command');
 
@@ -973,6 +1059,10 @@ export class ChatwootService {
           const state = waInstance?.connectionStatus?.state;
 
           if (state !== 'open') {
+            if (state === 'close') {
+              this.logger.verbose('request cleaning up instance: ' + instance.instanceName);
+              // await this.waMonitor.cleaningUp(instance.instanceName);
+            }
             this.logger.verbose('connect to whatsapp');
             const number = command.split(':')[1];
             await waInstance.connectToWhatsapp(number);
@@ -1036,7 +1126,13 @@ export class ChatwootService {
         if (senderName === null || senderName === undefined) {
           formatText = messageReceived;
         } else {
-          formatText = this.provider.sign_msg ? `*${senderName}:*\n${messageReceived}` : messageReceived;
+          const formattedDelimiter = this.provider.sign_delimiter
+            ? this.provider.sign_delimiter.replaceAll('\\n', '\n')
+            : '\n';
+          const textToConcat = this.provider.sign_msg ? [`*${senderName}:*`] : [];
+          textToConcat.push(messageReceived);
+
+          formatText = textToConcat.join(formattedDelimiter);
         }
 
         for (const message of body.conversation.messages) {
@@ -1050,7 +1146,30 @@ export class ChatwootService {
                 formatText = null;
               }
 
-              await this.sendAttachment(waInstance, chatId, attachment.data_url, formatText);
+              const options: Options = {
+                quoted: await this.getQuotedMessage(body, instance),
+              };
+
+              const messageSent = await this.sendAttachment(
+                waInstance,
+                chatId,
+                attachment.data_url,
+                formatText,
+                options,
+              );
+
+              this.updateChatwootMessageId(
+                {
+                  ...messageSent,
+                  owner: instance.instanceName,
+                },
+                {
+                  messageId: body.id,
+                  inboxId: body.inbox?.id,
+                  conversationId: body.conversation?.id,
+                },
+                instance,
+              );
             }
           } else {
             this.logger.verbose('message is text');
@@ -1064,10 +1183,24 @@ export class ChatwootService {
               options: {
                 delay: 1200,
                 presence: 'composing',
+                quoted: await this.getQuotedMessage(body, instance),
               },
             };
 
-            await waInstance?.textMessage(data);
+            const messageSent = await waInstance?.textMessage(data, true);
+
+            this.updateChatwootMessageId(
+              {
+                ...messageSent,
+                owner: instance.instanceName,
+              },
+              {
+                messageId: body.id,
+                inboxId: body.inbox?.id,
+                conversationId: body.conversation?.id,
+              },
+              instance,
+            );
           }
         }
       }
@@ -1099,6 +1232,78 @@ export class ChatwootService {
     }
   }
 
+  private updateChatwootMessageId(
+    message: MessageRaw,
+    chatwootMessageIds: MessageRaw['chatwoot'],
+    instance: InstanceDto,
+  ) {
+    if (!chatwootMessageIds.messageId || !message?.key?.id) {
+      return;
+    }
+
+    message.chatwoot = chatwootMessageIds;
+    this.repository.message.update([message], instance.instanceName, true);
+  }
+
+  private async getMessageByKeyId(instance: InstanceDto, keyId: string): Promise<MessageRaw> {
+    const messages = await this.repository.message.find({
+      where: {
+        key: {
+          id: keyId,
+        },
+        owner: instance.instanceName,
+      },
+      limit: 1,
+    });
+
+    return messages.length ? messages[0] : null;
+  }
+
+  private async getReplyToIds(
+    msg: any,
+    instance: InstanceDto,
+  ): Promise<{ in_reply_to: string; in_reply_to_external_id: string }> {
+    let inReplyTo = null;
+    let inReplyToExternalId = null;
+
+    if (msg) {
+      inReplyToExternalId = msg.message?.extendedTextMessage?.contextInfo?.stanzaId;
+      if (inReplyToExternalId) {
+        const message = await this.getMessageByKeyId(instance, inReplyToExternalId);
+        if (message?.chatwoot?.messageId) {
+          inReplyTo = message.chatwoot.messageId;
+        }
+      }
+    }
+
+    return {
+      in_reply_to: inReplyTo,
+      in_reply_to_external_id: inReplyToExternalId,
+    };
+  }
+
+  private async getQuotedMessage(msg: any, instance: InstanceDto): Promise<Quoted> {
+    if (msg?.content_attributes?.in_reply_to) {
+      const message = await this.repository.message.find({
+        where: {
+          chatwoot: {
+            messageId: msg?.content_attributes?.in_reply_to,
+          },
+          owner: instance.instanceName,
+        },
+        limit: 1,
+      });
+      if (message.length && message[0]?.key?.id) {
+        return {
+          key: message[0].key,
+          message: message[0].message,
+        };
+      }
+    }
+
+    return null;
+  }
+
   private isMediaMessage(message: any) {
     this.logger.verbose('check if is media message');
     const media = [
@@ -1118,6 +1323,32 @@ export class ChatwootService {
     return result;
   }
 
+  private getAdsMessage(msg: any) {
+    interface AdsMessage {
+      title: string;
+      body: string;
+      thumbnailUrl: string;
+      sourceUrl: string;
+    }
+    const adsMessage: AdsMessage | undefined = msg.extendedTextMessage?.contextInfo?.externalAdReply;
+
+    this.logger.verbose('Get ads message if it exist');
+    adsMessage && this.logger.verbose('Ads message: ' + adsMessage);
+    return adsMessage;
+  }
+
+  private getReactionMessage(msg: any) {
+    interface ReactionMessage {
+      key: MessageRaw['key'];
+      text: string;
+    }
+    const reactionMessage: ReactionMessage | undefined = msg?.reactionMessage;
+
+    this.logger.verbose('Get reaction message if it exists');
+    reactionMessage && this.logger.verbose('Reaction message: ' + reactionMessage);
+    return reactionMessage;
+  }
+
   private getTypeMessage(msg: any) {
     this.logger.verbose('get type message');
 
@@ -1184,6 +1415,11 @@ export class ChatwootService {
           formattedContact += `\n**number ${numberCount}:** ${phoneNumber}`;
           numberCount++;
         }
+        if (key.includes('TEL')) {
+          const phoneNumber = contactInfo[key];
+          formattedContact += `\n**number:** ${phoneNumber}`;
+          numberCount++;
+        }
       });
 
       this.logger.verbose('message content: ' + formattedContact);
@@ -1212,6 +1448,11 @@ export class ChatwootService {
             formattedContact += `\n**number ${numberCount}:** ${phoneNumber}`;
             numberCount++;
           }
+          if (key.includes('TEL')) {
+            const phoneNumber = contactInfo[key];
+            formattedContact += `\n**number:** ${phoneNumber}`;
+            numberCount++;
+          }
         });
 
         return formattedContact;
@@ -1244,13 +1485,6 @@ export class ChatwootService {
   public async eventWhatsapp(event: string, instance: InstanceDto, body: any) {
     this.logger.verbose('event whatsapp to instance: ' + instance.instanceName);
     try {
-      const client = await this.clientCw(instance);
-
-      if (!client) {
-        this.logger.warn('client not found');
-        return null;
-      }
-
       const waInstance = this.waMonitor.waInstances[instance.instanceName];
 
       if (!waInstance) {
@@ -1258,7 +1492,14 @@ export class ChatwootService {
         return null;
       }
 
-      if (event === 'messages.upsert') {
+      const client = await this.clientCw(instance);
+
+      if (!client) {
+        this.logger.warn('client not found');
+        return null;
+      }
+
+      if (event === 'messages.upsert' || event === 'send.message') {
         this.logger.verbose('event messages.upsert');
 
         if (body.key.remoteJid === 'status@broadcast') {
@@ -1267,19 +1508,38 @@ export class ChatwootService {
         }
 
         this.logger.verbose('get conversation message');
-        const bodyMessage = await this.getConversationMessage(body.message);
+
+        // Whatsapp to Chatwoot
+        const originalMessage = await this.getConversationMessage(body.message);
+        const bodyMessage = originalMessage
+          ? originalMessage
+              .replaceAll(/\*((?!\s)([^\n*]+?)(?<!\s))\*/g, '**$1**')
+              .replaceAll(/_((?!\s)([^\n_]+?)(?<!\s))_/g, '*$1*')
+              .replaceAll(/~((?!\s)([^\n~]+?)(?<!\s))~/g, '~~$1~~')
+          : originalMessage;
+
+        this.logger.verbose('body message: ' + bodyMessage);
+
+        if (bodyMessage && bodyMessage.includes('Por favor, classifique esta conversa, http')) {
+          this.logger.verbose('conversation is closed');
+          return;
+        }
 
         const isMedia = this.isMediaMessage(body.message);
 
-        if (!bodyMessage && !isMedia) {
+        const adsMessage = this.getAdsMessage(body.message);
+
+        const reactionMessage = this.getReactionMessage(body.message);
+
+        if (!bodyMessage && !isMedia && !reactionMessage) {
           this.logger.warn('no body message found');
           return;
         }
 
         this.logger.verbose('get conversation in chatwoot');
-        const getConversion = await this.createConversation(instance, body);
+        const getConversation = await this.createConversation(instance, body);
 
-        if (!getConversion) {
+        if (!getConversation) {
           this.logger.warn('conversation not found');
           return;
         }
@@ -1330,7 +1590,7 @@ export class ChatwootService {
             }
 
             this.logger.verbose('send data to chatwoot');
-            const send = await this.sendData(getConversion, fileName, messageType, content);
+            const send = await this.sendData(getConversation, fileName, messageType, content, instance, body);
 
             if (!send) {
               this.logger.warn('message not sent');
@@ -1351,7 +1611,7 @@ export class ChatwootService {
             this.logger.verbose('message is not group');
 
             this.logger.verbose('send data to chatwoot');
-            const send = await this.sendData(getConversion, fileName, messageType, bodyMessage);
+            const send = await this.sendData(getConversation, fileName, messageType, bodyMessage, instance, body);
 
             if (!send) {
               this.logger.warn('message not sent');
@@ -1371,6 +1631,98 @@ export class ChatwootService {
           }
         }
 
+        this.logger.verbose('check if has ReactionMessage');
+        if (reactionMessage) {
+          this.logger.verbose('send data to chatwoot');
+          if (reactionMessage.text) {
+            const send = await this.createMessage(
+              instance,
+              getConversation,
+              reactionMessage.text,
+              messageType,
+              false,
+              [],
+              {
+                message: { extendedTextMessage: { contextInfo: { stanzaId: reactionMessage.key.id } } },
+              },
+            );
+            if (!send) {
+              this.logger.warn('message not sent');
+              return;
+            }
+            this.messageCacheFile = path.join(ROOT_DIR, 'store', 'chatwoot', `${instance.instanceName}_cache.txt`);
+            this.messageCache = this.loadMessageCache();
+            this.messageCache.add(send.id.toString());
+            this.logger.verbose('save message cache');
+            this.saveMessageCache();
+          }
+
+          return;
+        }
+
+        this.logger.verbose('check if has Ads Message');
+        if (adsMessage) {
+          this.logger.verbose('message is from Ads');
+
+          this.logger.verbose('get base64 from media ads message');
+          const imgBuffer = await axios.get(adsMessage.thumbnailUrl, { responseType: 'arraybuffer' });
+
+          const extension = mimeTypes.extension(imgBuffer.headers['content-type']);
+          const mimeType = extension && mimeTypes.lookup(extension);
+
+          if (!mimeType) {
+            this.logger.warn('mimetype of Ads message not found');
+            return;
+          }
+
+          const random = Math.random().toString(36).substring(7);
+          const nameFile = `${random}.${mimeTypes.extension(mimeType)}`;
+          const fileData = Buffer.from(imgBuffer.data, 'binary');
+          const fileName = `${path.join(waInstance?.storePath, 'temp', `${nameFile}`)}`;
+
+          this.logger.verbose('temp file name: ' + nameFile);
+          this.logger.verbose('create temp file');
+          await Jimp.read(fileData)
+            .then(async (img) => {
+              await img.cover(320, 180).writeAsync(fileName);
+            })
+            .catch((err) => {
+              this.logger.error(`image is not write: ${err}`);
+            });
+          const truncStr = (str: string, len: number) => {
+            return str.length > len ? str.substring(0, len) + '...' : str;
+          };
+
+          const title = truncStr(adsMessage.title, 40);
+          const description = truncStr(adsMessage.body, 75);
+
+          this.logger.verbose('send data to chatwoot');
+          const send = await this.sendData(
+            getConversation,
+            fileName,
+            messageType,
+            `${bodyMessage}\n\n\n**${title}**\n${description}\n${adsMessage.sourceUrl}`,
+            instance,
+            body,
+          );
+
+          if (!send) {
+            this.logger.warn('message not sent');
+            return;
+          }
+
+          this.messageCacheFile = path.join(ROOT_DIR, 'store', 'chatwoot', `${instance.instanceName}_cache.txt`);
+
+          this.messageCache = this.loadMessageCache();
+
+          this.messageCache.add(send.id.toString());
+
+          this.logger.verbose('save message cache');
+          this.saveMessageCache();
+
+          return send;
+        }
+
         this.logger.verbose('check if is group');
         if (body.key.remoteJid.includes('@g.us')) {
           this.logger.verbose('message is group');
@@ -1387,7 +1739,7 @@ export class ChatwootService {
           }
 
           this.logger.verbose('send data to chatwoot');
-          const send = await this.createMessage(instance, getConversion, content, messageType);
+          const send = await this.createMessage(instance, getConversation, content, messageType, false, [], body);
 
           if (!send) {
             this.logger.warn('message not sent');
@@ -1408,7 +1760,7 @@ export class ChatwootService {
           this.logger.verbose('message is not group');
 
           this.logger.verbose('send data to chatwoot');
-          const send = await this.createMessage(instance, getConversion, bodyMessage, messageType);
+          const send = await this.createMessage(instance, getConversation, bodyMessage, messageType, false, [], body);
 
           if (!send) {
             this.logger.warn('message not sent');
@@ -1428,6 +1780,25 @@ export class ChatwootService {
         }
       }
 
+      if (event === Events.MESSAGES_DELETE) {
+        this.logger.verbose('deleting message from instance: ' + instance.instanceName);
+
+        if (!body?.key?.id) {
+          this.logger.warn('message id not found');
+          return;
+        }
+
+        const message = await this.getMessageByKeyId(instance, body.key.id);
+        if (message?.chatwoot?.messageId && message?.chatwoot?.conversationId) {
+          this.logger.verbose('deleting message in chatwoot. Message id: ' + body.key.id);
+          return await client.messages.delete({
+            accountId: this.provider.account_id,
+            conversationId: message.chatwoot.conversationId,
+            messageId: message.chatwoot.messageId,
+          });
+        }
+      }
+
       if (event === 'status.instance') {
         this.logger.verbose('event status.instance');
         const data = body;
@@ -1448,10 +1819,12 @@ export class ChatwootService {
         this.logger.verbose('event connection.update');
 
         if (body.status === 'open') {
-          const msgConnection = `🚀 Connection successfully established!`;
-
-          this.logger.verbose('send message to chatwoot');
-          await this.createBotMessage(instance, msgConnection, 'incoming');
+          // if we have qrcode count then we understand that a new connection was established
+          if (this.waMonitor.waInstances[instance.instanceName].qrCode.count > 0) {
+            const msgConnection = `🚀 Connection successfully established!`;
+            this.logger.verbose('send message to chatwoot');
+            await this.createBotMessage(instance, msgConnection, 'incoming');
+          }
         }
       }
 

src/whatsapp/services/monitor.service.ts

@@ -12,12 +12,18 @@ import { dbserver } from '../../libs/db.connect';
 import { RedisCache } from '../../libs/redis.client';
 import {
   AuthModel,
+  ChamaaiModel,
+  // ChatModel,
   ChatwootModel,
-  ContactModel,
-  MessageModel,
-  MessageUpModel,
+  // ContactModel,
+  // MessageModel,
+  // MessageUpModel,
+  ProxyModel,
+  RabbitmqModel,
   SettingsModel,
+  TypebotModel,
   WebhookModel,
+  WebsocketModel,
 } from '../models';
 import { RepositoryBroker } from '../repository/repository.manager';
 import { WAStartupService } from './whatsapp.service';
@@ -33,7 +39,7 @@ export class WAMonitoringService {
 
     this.removeInstance();
     this.noConnection();
-    this.delInstanceFiles();
+    // this.delInstanceFiles();
 
     Object.assign(this.db, configService.get<Database>('DATABASE'));
     Object.assign(this.redis, configService.get<Redis>('REDIS'));
@@ -64,8 +70,10 @@ export class WAMonitoringService {
             await this.waInstances[instance]?.client?.logout('Log out instance: ' + instance);
             this.waInstances[instance]?.client?.ws?.close();
             this.waInstances[instance]?.client?.end(undefined);
+            this.waInstances[instance]?.removeRabbitmqQueues();
             delete this.waInstances[instance];
           } else {
+            this.waInstances[instance]?.removeRabbitmqQueues();
             delete this.waInstances[instance];
             this.eventEmitter.emit('remove.instance', instance, 'inner');
           }
@@ -104,6 +112,7 @@ export class WAMonitoringService {
           const instanceData = {
             instance: {
               instanceName: key,
+              instanceId: (await this.repository.auth.find(key))?.instanceId,
               owner: value.wuid,
               profileName: (await value.getProfileName()) || 'not loaded',
               profilePictureUrl: value.profilePictureUrl,
@@ -115,7 +124,7 @@ export class WAMonitoringService {
           if (this.configService.get<Auth>('AUTHENTICATION').EXPOSE_IN_FETCH_INSTANCES) {
             instanceData.instance['serverUrl'] = this.configService.get<HttpServer>('SERVER').URL;
 
-            instanceData.instance['apikey'] = (await this.repository.auth.find(key)).apikey;
+            instanceData.instance['apikey'] = (await this.repository.auth.find(key))?.apikey;
 
             instanceData.instance['chatwoot'] = chatwoot;
           }
@@ -127,6 +136,7 @@ export class WAMonitoringService {
           const instanceData = {
             instance: {
               instanceName: key,
+              instanceId: (await this.repository.auth.find(key))?.instanceId,
               status: value.connectionStatus.state,
             },
           };
@@ -134,7 +144,89 @@ export class WAMonitoringService {
           if (this.configService.get<Auth>('AUTHENTICATION').EXPOSE_IN_FETCH_INSTANCES) {
             instanceData.instance['serverUrl'] = this.configService.get<HttpServer>('SERVER').URL;
 
-            instanceData.instance['apikey'] = (await this.repository.auth.find(key)).apikey;
+            instanceData.instance['apikey'] = (await this.repository.auth.find(key))?.apikey;
+
+            instanceData.instance['chatwoot'] = chatwoot;
+          }
+
+          instances.push(instanceData);
+        }
+      }
+    }
+
+    this.logger.verbose('return instance info: ' + instances.length);
+
+    return instances.find((i) => i.instance.instanceName === instanceName) ?? instances;
+  }
+
+  public async instanceInfoById(instanceId?: string) {
+    this.logger.verbose('get instance info');
+    const instanceName = await this.repository.auth.findInstanceNameById(instanceId);
+    if (!instanceName) {
+      throw new NotFoundException(`Instance "${instanceId}" not found`);
+    }
+
+    if (instanceName && !this.waInstances[instanceName]) {
+      throw new NotFoundException(`Instance "${instanceName}" not found`);
+    }
+
+    const instances: any[] = [];
+
+    for await (const [key, value] of Object.entries(this.waInstances)) {
+      if (value) {
+        this.logger.verbose('get instance info: ' + key);
+        let chatwoot: any;
+
+        const urlServer = this.configService.get<HttpServer>('SERVER').URL;
+
+        const findChatwoot = await this.waInstances[key].findChatwoot();
+
+        if (findChatwoot && findChatwoot.enabled) {
+          chatwoot = {
+            ...findChatwoot,
+            webhook_url: `${urlServer}/chatwoot/webhook/${encodeURIComponent(key)}`,
+          };
+        }
+
+        if (value.connectionStatus.state === 'open') {
+          this.logger.verbose('instance: ' + key + ' - connectionStatus: open');
+
+          const instanceData = {
+            instance: {
+              instanceName: key,
+              instanceId: (await this.repository.auth.find(key))?.instanceId,
+              owner: value.wuid,
+              profileName: (await value.getProfileName()) || 'not loaded',
+              profilePictureUrl: value.profilePictureUrl,
+              profileStatus: (await value.getProfileStatus()) || '',
+              status: value.connectionStatus.state,
+            },
+          };
+
+          if (this.configService.get<Auth>('AUTHENTICATION').EXPOSE_IN_FETCH_INSTANCES) {
+            instanceData.instance['serverUrl'] = this.configService.get<HttpServer>('SERVER').URL;
+
+            instanceData.instance['apikey'] = (await this.repository.auth.find(key))?.apikey;
+
+            instanceData.instance['chatwoot'] = chatwoot;
+          }
+
+          instances.push(instanceData);
+        } else {
+          this.logger.verbose('instance: ' + key + ' - connectionStatus: ' + value.connectionStatus.state);
+
+          const instanceData = {
+            instance: {
+              instanceName: key,
+              instanceId: (await this.repository.auth.find(key))?.instanceId,
+              status: value.connectionStatus.state,
+            },
+          };
+
+          if (this.configService.get<Auth>('AUTHENTICATION').EXPOSE_IN_FETCH_INSTANCES) {
+            instanceData.instance['serverUrl'] = this.configService.get<HttpServer>('SERVER').URL;
+
+            instanceData.instance['apikey'] = (await this.repository.auth.find(key))?.apikey;
 
             instanceData.instance['chatwoot'] = chatwoot;
           }
@@ -161,8 +253,7 @@ export class WAMonitoringService {
           });
           this.logger.verbose('instance files deleted: ' + name);
         });
-        // } else if (this.redis.ENABLED) {
-      } else {
+      } else if (!this.redis.ENABLED) {
         const dir = opendirSync(INSTANCE_DIR, { encoding: 'utf-8' });
         for await (const dirent of dir) {
           if (dirent.isDirectory()) {
@@ -186,6 +277,7 @@ export class WAMonitoringService {
 
   public async cleaningUp(instanceName: string) {
     this.logger.verbose('cleaning up instance: ' + instanceName);
+
     if (this.db.ENABLED && this.db.SAVE_DATA.INSTANCE) {
       this.logger.verbose('cleaning up instance in database: ' + instanceName);
       await this.repository.dbServer.connect();
@@ -220,6 +312,11 @@ export class WAMonitoringService {
       execSync(`rm -rf ${join(STORE_DIR, 'auth', 'apikey', instanceName + '.json')}`);
       execSync(`rm -rf ${join(STORE_DIR, 'webhook', instanceName + '.json')}`);
       execSync(`rm -rf ${join(STORE_DIR, 'chatwoot', instanceName + '*')}`);
+      execSync(`rm -rf ${join(STORE_DIR, 'chamaai', instanceName + '*')}`);
+      execSync(`rm -rf ${join(STORE_DIR, 'proxy', instanceName + '*')}`);
+      execSync(`rm -rf ${join(STORE_DIR, 'rabbitmq', instanceName + '*')}`);
+      execSync(`rm -rf ${join(STORE_DIR, 'typebot', instanceName + '*')}`);
+      execSync(`rm -rf ${join(STORE_DIR, 'websocket', instanceName + '*')}`);
       execSync(`rm -rf ${join(STORE_DIR, 'settings', instanceName + '*')}`);
 
       return;
@@ -227,81 +324,103 @@ export class WAMonitoringService {
 
     this.logger.verbose('cleaning store database instance: ' + instanceName);
 
-    await AuthModel.deleteMany({ owner: instanceName });
-    await ContactModel.deleteMany({ owner: instanceName });
-    await MessageModel.deleteMany({ owner: instanceName });
-    await MessageUpModel.deleteMany({ owner: instanceName });
+    // await ChatModel.deleteMany({ owner: instanceName });
+    // await ContactModel.deleteMany({ owner: instanceName });
+    // await MessageUpModel.deleteMany({ owner: instanceName });
+    // await MessageModel.deleteMany({ owner: instanceName });
+
     await AuthModel.deleteMany({ _id: instanceName });
     await WebhookModel.deleteMany({ _id: instanceName });
     await ChatwootModel.deleteMany({ _id: instanceName });
+    await ChamaaiModel.deleteMany({ _id: instanceName });
+    await ProxyModel.deleteMany({ _id: instanceName });
+    await RabbitmqModel.deleteMany({ _id: instanceName });
+    await TypebotModel.deleteMany({ _id: instanceName });
+    await WebsocketModel.deleteMany({ _id: instanceName });
     await SettingsModel.deleteMany({ _id: instanceName });
 
     return;
   }
 
   public async loadInstance() {
-    this.logger.verbose('load instances');
-    const set = async (name: string) => {
-      const instance = new WAStartupService(this.configService, this.eventEmitter, this.repository, this.cache);
-      instance.instanceName = name;
-      this.logger.verbose('instance loaded: ' + name);
-
-      await instance.connectToWhatsapp();
-      this.logger.verbose('connectToWhatsapp: ' + name);
-
-      this.waInstances[name] = instance;
-    };
+    this.logger.verbose('Loading instances');
 
     try {
       if (this.redis.ENABLED) {
-        this.logger.verbose('redis enabled');
-        await this.cache.connect(this.redis as Redis);
-        const keys = await this.cache.instanceKeys();
-        if (keys?.length > 0) {
-          this.logger.verbose('reading instance keys and setting instances');
-          keys.forEach(async (k) => await set(k.split(':')[1]));
-        } else {
-          this.logger.verbose('no instance keys found');
-        }
-        return;
-      }
-
-      if (this.db.ENABLED && this.db.SAVE_DATA.INSTANCE) {
-        this.logger.verbose('database enabled');
-        await this.repository.dbServer.connect();
-        const collections: any[] = await this.dbInstance.collections();
-        if (collections.length > 0) {
-          this.logger.verbose('reading collections and setting instances');
-          collections.forEach(async (coll) => await set(coll.namespace.replace(/^[\w-]+\./, '')));
-        } else {
-          this.logger.verbose('no collections found');
-        }
-        return;
-      }
-
-      this.logger.verbose('store in files enabled');
-      const dir = opendirSync(INSTANCE_DIR, { encoding: 'utf-8' });
-      for await (const dirent of dir) {
-        if (dirent.isDirectory()) {
-          this.logger.verbose('reading instance files and setting instances');
-          const files = readdirSync(join(INSTANCE_DIR, dirent.name), {
-            encoding: 'utf-8',
-          });
-          if (files.length === 0) {
-            rmSync(join(INSTANCE_DIR, dirent.name), { recursive: true, force: true });
-            break;
-          }
-
-          await set(dirent.name);
-        } else {
-          this.logger.verbose('no instance files found');
-        }
+        await this.loadInstancesFromRedis();
+      } else if (this.db.ENABLED && this.db.SAVE_DATA.INSTANCE) {
+        await this.loadInstancesFromDatabase();
+      } else {
+        await this.loadInstancesFromFiles();
       }
     } catch (error) {
       this.logger.error(error);
     }
   }
 
+  private async setInstance(name: string) {
+    const instance = new WAStartupService(this.configService, this.eventEmitter, this.repository, this.cache);
+    instance.instanceName = name;
+    this.logger.verbose('Instance loaded: ' + name);
+    await instance.connectToWhatsapp();
+    this.logger.verbose('connectToWhatsapp: ' + name);
+
+    this.waInstances[name] = instance;
+  }
+
+  private async loadInstancesFromRedis() {
+    this.logger.verbose('Redis enabled');
+    await this.cache.connect(this.redis as Redis);
+    const keys = await this.cache.instanceKeys();
+
+    if (keys?.length > 0) {
+      this.logger.verbose('Reading instance keys and setting instances');
+      await Promise.all(keys.map((k) => this.setInstance(k.split(':')[1])));
+    } else {
+      this.logger.verbose('No instance keys found');
+    }
+  }
+
+  private async loadInstancesFromDatabase() {
+    this.logger.verbose('Database enabled');
+    await this.repository.dbServer.connect();
+    const collections: any[] = await this.dbInstance.collections();
+
+    if (collections.length > 0) {
+      this.logger.verbose('Reading collections and setting instances');
+      await Promise.all(collections.map((coll) => this.setInstance(coll.namespace.replace(/^[\w-]+\./, ''))));
+    } else {
+      this.logger.verbose('No collections found');
+    }
+  }
+
+  private async loadInstancesFromFiles() {
+    this.logger.verbose('Store in files enabled');
+    const dir = opendirSync(INSTANCE_DIR, { encoding: 'utf-8' });
+    const instanceDirs = [];
+
+    for await (const dirent of dir) {
+      if (dirent.isDirectory()) {
+        instanceDirs.push(dirent.name);
+      } else {
+        this.logger.verbose('No instance files found');
+      }
+    }
+
+    await Promise.all(
+      instanceDirs.map(async (instanceName) => {
+        this.logger.verbose('Reading instance files and setting instances: ' + instanceName);
+        const files = readdirSync(join(INSTANCE_DIR, instanceName), { encoding: 'utf-8' });
+
+        if (files.length === 0) {
+          rmSync(join(INSTANCE_DIR, instanceName), { recursive: true, force: true });
+        } else {
+          await this.setInstance(instanceName);
+        }
+      }),
+    );
+  }
+
   private removeInstance() {
     this.eventEmitter.on('remove.instance', async (instanceName: string) => {
       this.logger.verbose('remove instance: ' + instanceName);

src/whatsapp/services/proxy.service.ts

@@ -9,9 +9,9 @@ export class ProxyService {
 
   private readonly logger = new Logger(ProxyService.name);
 
-  public create(instance: InstanceDto, data: ProxyDto) {
+  public create(instance: InstanceDto, data: ProxyDto, reload = true) {
     this.logger.verbose('create proxy: ' + instance.instanceName);
-    this.waMonitor.waInstances[instance.instanceName].setProxy(data);
+    this.waMonitor.waInstances[instance.instanceName].setProxy(data, reload);
 
     return { proxy: { ...instance, proxy: data } };
   }

src/whatsapp/services/rabbitmq.service.ts

@@ -1,4 +1,5 @@
 import { Logger } from '../../config/logger.config';
+import { initQueues } from '../../libs/amqp.server';
 import { InstanceDto } from '../dto/instance.dto';
 import { RabbitmqDto } from '../dto/rabbitmq.dto';
 import { RabbitmqRaw } from '../models';
@@ -13,6 +14,7 @@ export class RabbitmqService {
     this.logger.verbose('create rabbitmq: ' + instance.instanceName);
     this.waMonitor.waInstances[instance.instanceName].setRabbitmq(data);
 
+    initQueues(instance.instanceName, data.events);
     return { rabbitmq: { ...instance, rabbitmq: data } };
   }
 

src/whatsapp/services/settings.service.ts

@@ -26,7 +26,7 @@ export class SettingsService {
 
       return result;
     } catch (error) {
-      return { reject_call: false, msg_call: '', groups_ignore: false };
+      return { reject_call: false, msg_call: '', groups_ignore: true };
     }
   }
 }

src/whatsapp/services/sqs.service.ts

@@ -0,0 +1,35 @@
+import { Logger } from '../../config/logger.config';
+import { initQueues } from '../../libs/sqs.server';
+import { InstanceDto } from '../dto/instance.dto';
+import { SqsDto } from '../dto/sqs.dto';
+import { SqsRaw } from '../models';
+import { WAMonitoringService } from './monitor.service';
+
+export class SqsService {
+  constructor(private readonly waMonitor: WAMonitoringService) {}
+
+  private readonly logger = new Logger(SqsService.name);
+
+  public create(instance: InstanceDto, data: SqsDto) {
+    this.logger.verbose('create sqs: ' + instance.instanceName);
+    this.waMonitor.waInstances[instance.instanceName].setSqs(data);
+
+    initQueues(instance.instanceName, data.events);
+    return { sqs: { ...instance, sqs: data } };
+  }
+
+  public async find(instance: InstanceDto): Promise<SqsRaw> {
+    try {
+      this.logger.verbose('find sqs: ' + instance.instanceName);
+      const result = await this.waMonitor.waInstances[instance.instanceName].findSqs();
+
+      if (Object.keys(result).length === 0) {
+        throw new Error('Sqs not found');
+      }
+
+      return result;
+    } catch (error) {
+      return { enabled: false, events: [] };
+    }
+  }
+}

src/whatsapp/services/typebot.service.ts

@@ -1,13 +1,27 @@
 import axios from 'axios';
+import EventEmitter2 from 'eventemitter2';
 
+import { ConfigService, Typebot } from '../../config/env.config';
 import { Logger } from '../../config/logger.config';
 import { InstanceDto } from '../dto/instance.dto';
 import { Session, TypebotDto } from '../dto/typebot.dto';
 import { MessageRaw } from '../models';
+import { Events } from '../types/wa.types';
 import { WAMonitoringService } from './monitor.service';
 
 export class TypebotService {
-  constructor(private readonly waMonitor: WAMonitoringService) {}
+  constructor(
+    private readonly waMonitor: WAMonitoringService,
+    private readonly configService: ConfigService,
+    private readonly eventEmitter: EventEmitter2,
+  ) {
+    this.eventEmitter.on('typebot:end', async (data) => {
+      const keep_open = this.configService.get<Typebot>('TYPEBOT').KEEP_OPEN;
+      if (keep_open) return;
+
+      await this.clearSessions(data.instance, data.remoteJid);
+    });
+  }
 
   private readonly logger = new Logger(TypebotService.name);
 
@@ -46,13 +60,14 @@ export class TypebotService {
         findData.sessions.splice(findData.sessions.indexOf(session), 1);
 
         const typebotData = {
-          enabled: true,
+          enabled: findData.enabled,
           url: findData.url,
           typebot: findData.typebot,
           expire: findData.expire,
           keyword_finish: findData.keyword_finish,
           delay_message: findData.delay_message,
           unknown_message: findData.unknown_message,
+          listening_from_me: findData.listening_from_me,
           sessions: findData.sessions,
         };
 
@@ -66,53 +81,179 @@ export class TypebotService {
           session.status = status;
         }
       });
+    } else if (status === 'paused') {
+      const session: Session = {
+        remoteJid: remoteJid,
+        sessionId: Math.floor(Math.random() * 10000000000).toString(),
+        status: status,
+        createdAt: Date.now(),
+        updateAt: Date.now(),
+        prefilledVariables: {
+          remoteJid: remoteJid,
+          pushName: '',
+          additionalData: {},
+        },
+      };
+      findData.sessions.push(session);
     }
 
     const typebotData = {
-      enabled: true,
+      enabled: findData.enabled,
       url: findData.url,
       typebot: findData.typebot,
       expire: findData.expire,
       keyword_finish: findData.keyword_finish,
       delay_message: findData.delay_message,
       unknown_message: findData.unknown_message,
+      listening_from_me: findData.listening_from_me,
       sessions: findData.sessions,
     };
 
     this.create(instance, typebotData);
 
+    this.waMonitor.waInstances[instance.instanceName].sendDataWebhook(Events.TYPEBOT_CHANGE_STATUS, {
+      remoteJid: remoteJid,
+      status: status,
+      url: findData.url,
+      typebot: findData.typebot,
+      session,
+    });
+
     return { typebot: { ...instance, typebot: typebotData } };
   }
 
+  public async clearSessions(instance: InstanceDto, remoteJid: string) {
+    const findTypebot = await this.find(instance);
+    const sessions = (findTypebot.sessions as Session[]) ?? [];
+
+    const sessionWithRemoteJid = sessions.filter((session) => session.remoteJid === remoteJid);
+
+    if (sessionWithRemoteJid.length > 0) {
+      sessionWithRemoteJid.forEach((session) => {
+        sessions.splice(sessions.indexOf(session), 1);
+      });
+
+      const typebotData = {
+        enabled: findTypebot.enabled,
+        url: findTypebot.url,
+        typebot: findTypebot.typebot,
+        expire: findTypebot.expire,
+        keyword_finish: findTypebot.keyword_finish,
+        delay_message: findTypebot.delay_message,
+        unknown_message: findTypebot.unknown_message,
+        listening_from_me: findTypebot.listening_from_me,
+        sessions,
+      };
+
+      this.create(instance, typebotData);
+
+      return sessions;
+    }
+
+    return sessions;
+  }
+
   public async startTypebot(instance: InstanceDto, data: any) {
+    if (data.remoteJid === 'status@broadcast') return;
+
     const remoteJid = data.remoteJid;
     const url = data.url;
     const typebot = data.typebot;
+    const startSession = data.startSession;
+    const variables = data.variables;
+    const findTypebot = await this.find(instance);
+    const expire = findTypebot.expire;
+    const keyword_finish = findTypebot.keyword_finish;
+    const delay_message = findTypebot.delay_message;
+    const unknown_message = findTypebot.unknown_message;
+    const listening_from_me = findTypebot.listening_from_me;
 
-    const id = Math.floor(Math.random() * 10000000000).toString();
-
-    const reqData = {
-      sessionId: id,
-      startParams: {
-        typebot: data.typebot,
-        prefilledVariables: {
-          remoteJid: data.remoteJid,
-          pushName: data.pushName,
-          instanceName: instance.instanceName,
-        },
-      },
+    const prefilledVariables = {
+      remoteJid: remoteJid,
+      instanceName: instance.instanceName,
     };
-    console.log(reqData);
 
-    const request = await axios.post(data.url + '/api/v1/sendMessage', reqData);
+    if (variables?.length) {
+      variables.forEach((variable: { name: string | number; value: string }) => {
+        prefilledVariables[variable.name] = variable.value;
+      });
+    }
 
-    await this.sendWAMessage(
-      instance,
-      remoteJid,
-      request.data.messages,
-      request.data.input,
-      request.data.clientSideActions,
-    );
+    if (startSession) {
+      const newSessions = await this.clearSessions(instance, remoteJid);
+
+      const response = await this.createNewSession(instance, {
+        enabled: findTypebot.enabled,
+        url: url,
+        typebot: typebot,
+        remoteJid: remoteJid,
+        expire: expire,
+        keyword_finish: keyword_finish,
+        delay_message: delay_message,
+        unknown_message: unknown_message,
+        listening_from_me: listening_from_me,
+        sessions: newSessions,
+        prefilledVariables: prefilledVariables,
+      });
+
+      if (response.sessionId) {
+        await this.sendWAMessage(instance, remoteJid, response.messages, response.input, response.clientSideActions);
+
+        this.waMonitor.waInstances[instance.instanceName].sendDataWebhook(Events.TYPEBOT_START, {
+          remoteJid: remoteJid,
+          url: url,
+          typebot: typebot,
+          prefilledVariables: prefilledVariables,
+          sessionId: `${response.sessionId}`,
+        });
+      } else {
+        throw new Error('Session ID not found in response');
+      }
+    } else {
+      const id = Math.floor(Math.random() * 10000000000).toString();
+
+      try {
+        const version = this.configService.get<Typebot>('TYPEBOT').API_VERSION;
+        let url: string;
+        let reqData: {};
+        if (version === 'latest') {
+          url = `${data.url}/api/v1/typebots/${data.typebot}/startChat`;
+
+          reqData = {
+            prefilledVariables: prefilledVariables,
+          };
+        } else {
+          url = `${data.url}/api/v1/sendMessage`;
+
+          reqData = {
+            startParams: {
+              publicId: data.typebot,
+              prefilledVariables: prefilledVariables,
+            },
+          };
+        }
+        const request = await axios.post(url, reqData);
+
+        await this.sendWAMessage(
+          instance,
+          remoteJid,
+          request.data.messages,
+          request.data.input,
+          request.data.clientSideActions,
+        );
+
+        this.waMonitor.waInstances[instance.instanceName].sendDataWebhook(Events.TYPEBOT_START, {
+          remoteJid: remoteJid,
+          url: url,
+          typebot: typebot,
+          variables: variables,
+          sessionId: id,
+        });
+      } catch (error) {
+        this.logger.error(error);
+        return;
+      }
+    }
 
     return {
       typebot: {
@@ -121,6 +262,7 @@ export class TypebotService {
           url: url,
           remoteJid: remoteJid,
           typebot: typebot,
+          prefilledVariables: prefilledVariables,
         },
       },
     };
@@ -163,45 +305,75 @@ export class TypebotService {
   }
 
   public async createNewSession(instance: InstanceDto, data: any) {
+    if (data.remoteJid === 'status@broadcast') return;
     const id = Math.floor(Math.random() * 10000000000).toString();
-    const reqData = {
-      sessionId: id,
-      startParams: {
-        typebot: data.typebot,
-        prefilledVariables: {
+
+    try {
+      const version = this.configService.get<Typebot>('TYPEBOT').API_VERSION;
+      let url: string;
+      let reqData: {};
+      if (version === 'latest') {
+        url = `${data.url}/api/v1/typebots/${data.typebot}/startChat`;
+
+        reqData = {
+          prefilledVariables: {
+            ...data.prefilledVariables,
+            remoteJid: data.remoteJid,
+            pushName: data.pushName || data.prefilledVariables?.pushName || '',
+            instanceName: instance.instanceName,
+          },
+        };
+      } else {
+        url = `${data.url}/api/v1/sendMessage`;
+
+        reqData = {
+          startParams: {
+            publicId: data.typebot,
+            prefilledVariables: {
+              ...data.prefilledVariables,
+              remoteJid: data.remoteJid,
+              pushName: data.pushName || data.prefilledVariables?.pushName || '',
+              instanceName: instance.instanceName,
+            },
+          },
+        };
+      }
+      const request = await axios.post(url, reqData);
+
+      if (request?.data?.sessionId) {
+        data.sessions.push({
           remoteJid: data.remoteJid,
-          pushName: data.pushName,
-          instanceName: instance.instanceName,
-        },
-      },
-    };
+          sessionId: `${id}-${request.data.sessionId}`,
+          status: 'opened',
+          createdAt: Date.now(),
+          updateAt: Date.now(),
+          prefilledVariables: {
+            ...data.prefilledVariables,
+            remoteJid: data.remoteJid,
+            pushName: data.pushName || '',
+            instanceName: instance.instanceName,
+          },
+        });
 
-    const request = await axios.post(data.url + '/api/v1/sendMessage', reqData);
+        const typebotData = {
+          enabled: data.enabled,
+          url: data.url,
+          typebot: data.typebot,
+          expire: data.expire,
+          keyword_finish: data.keyword_finish,
+          delay_message: data.delay_message,
+          unknown_message: data.unknown_message,
+          listening_from_me: data.listening_from_me,
+          sessions: data.sessions,
+        };
 
-    if (request.data.sessionId) {
-      data.sessions.push({
-        remoteJid: data.remoteJid,
-        sessionId: `${id}-${request.data.sessionId}`,
-        status: 'opened',
-        createdAt: Date.now(),
-        updateAt: Date.now(),
-      });
-
-      const typebotData = {
-        enabled: true,
-        url: data.url,
-        typebot: data.typebot,
-        expire: data.expire,
-        keyword_finish: data.keyword_finish,
-        delay_message: data.delay_message,
-        unknown_message: data.unknown_message,
-        sessions: data.sessions,
-      };
-
-      this.create(instance, typebotData);
+        this.create(instance, typebotData);
+      }
+      return request.data;
+    } catch (error) {
+      this.logger.error(error);
+      return;
     }
-
-    return request.data;
   }
 
   public async sendWAMessage(
@@ -211,11 +383,15 @@ export class TypebotService {
     input: any[],
     clientSideActions: any[],
   ) {
-    processMessages(this.waMonitor.waInstances[instance.instanceName], messages, input, clientSideActions).catch(
-      (err) => {
-        console.error('Erro ao processar mensagens:', err);
-      },
-    );
+    processMessages(
+      this.waMonitor.waInstances[instance.instanceName],
+      messages,
+      input,
+      clientSideActions,
+      this.eventEmitter,
+    ).catch((err) => {
+      console.error('Erro ao processar mensagens:', err);
+    });
 
     function findItemAndGetSecondsToWait(array, targetId) {
       if (!array) return null;
@@ -228,7 +404,7 @@ export class TypebotService {
       return null;
     }
 
-    async function processMessages(instance, messages, input, clientSideActions) {
+    async function processMessages(instance, messages, input, clientSideActions, eventEmitter) {
       for (const message of messages) {
         const wait = findItemAndGetSecondsToWait(clientSideActions, message.id);
 
@@ -238,31 +414,50 @@ export class TypebotService {
           let linkPreview = false;
 
           for (const richText of message.content.richText) {
-            for (const element of richText.children) {
-              let text = '';
-              if (element.text) {
-                text = element.text;
+            if (richText.type === 'variable') {
+              for (const child of richText.children) {
+                for (const grandChild of child.children) {
+                  formattedText += grandChild.text;
+                }
               }
+            } else {
+              for (const element of richText.children) {
+                let text = '';
 
-              if (element.bold) {
-                text = `*${text}*`;
+                if (element.type === 'inline-variable') {
+                  for (const child of element.children) {
+                    for (const grandChild of child.children) {
+                      text += grandChild.text;
+                    }
+                  }
+                } else if (element.text) {
+                  text = element.text;
+                }
+
+                // if (element.text) {
+                //   text = element.text;
+                // }
+
+                if (element.bold) {
+                  text = `*${text}*`;
+                }
+
+                if (element.italic) {
+                  text = `_${text}_`;
+                }
+
+                if (element.underline) {
+                  text = `*${text}*`;
+                }
+
+                if (element.url) {
+                  const linkText = element.children[0].text;
+                  text = `[${linkText}](${element.url})`;
+                  linkPreview = true;
+                }
+
+                formattedText += text;
               }
-
-              if (element.italic) {
-                text = `_${text}_`;
-              }
-
-              if (element.underline) {
-                text = `~${text}~`;
-              }
-
-              if (element.url) {
-                const linkText = element.children[0].text;
-                text = `[${linkText}](${element.url})`;
-                linkPreview = true;
-              }
-
-              formattedText += text;
             }
             formattedText += '\n';
           }
@@ -349,38 +544,144 @@ export class TypebotService {
             },
           });
         }
+      } else {
+        eventEmitter.emit('typebot:end', {
+          instance: instance,
+          remoteJid: remoteJid,
+        });
       }
     }
   }
 
   public async sendTypebot(instance: InstanceDto, remoteJid: string, msg: MessageRaw) {
-    const url = (await this.find(instance)).url;
-    const typebot = (await this.find(instance)).typebot;
-    const sessions = ((await this.find(instance)).sessions as Session[]) ?? [];
-    const expire = (await this.find(instance)).expire;
-    const keyword_finish = (await this.find(instance)).keyword_finish;
-    const delay_message = (await this.find(instance)).delay_message;
-    const unknown_message = (await this.find(instance)).unknown_message;
+    const findTypebot = await this.find(instance);
+    const url = findTypebot.url;
+    const typebot = findTypebot.typebot;
+    const sessions = (findTypebot.sessions as Session[]) ?? [];
+    const expire = findTypebot.expire;
+    const keyword_finish = findTypebot.keyword_finish;
+    const delay_message = findTypebot.delay_message;
+    const unknown_message = findTypebot.unknown_message;
+    const listening_from_me = findTypebot.listening_from_me;
 
     const session = sessions.find((session) => session.remoteJid === remoteJid);
 
-    if (session && expire && expire > 0) {
-      const now = Date.now();
+    try {
+      if (session && expire && expire > 0) {
+        const now = Date.now();
 
-      const diff = now - session.updateAt;
+        const diff = now - session.updateAt;
 
-      const diffInMinutes = Math.floor(diff / 1000 / 60);
+        const diffInMinutes = Math.floor(diff / 1000 / 60);
 
-      if (diffInMinutes > expire) {
-        sessions.splice(sessions.indexOf(session), 1);
+        if (diffInMinutes > expire) {
+          const newSessions = await this.clearSessions(instance, remoteJid);
 
+          const data = await this.createNewSession(instance, {
+            enabled: findTypebot.enabled,
+            url: url,
+            typebot: typebot,
+            expire: expire,
+            keyword_finish: keyword_finish,
+            delay_message: delay_message,
+            unknown_message: unknown_message,
+            listening_from_me: listening_from_me,
+            sessions: newSessions,
+            remoteJid: remoteJid,
+            pushName: msg.pushName,
+          });
+
+          await this.sendWAMessage(instance, remoteJid, data.messages, data.input, data.clientSideActions);
+
+          if (data.messages.length === 0) {
+            const content = this.getConversationMessage(msg.message);
+
+            if (!content) {
+              if (unknown_message) {
+                this.waMonitor.waInstances[instance.instanceName].textMessage({
+                  number: remoteJid.split('@')[0],
+                  options: {
+                    delay: delay_message || 1000,
+                    presence: 'composing',
+                  },
+                  textMessage: {
+                    text: unknown_message,
+                  },
+                });
+              }
+              return;
+            }
+
+            if (keyword_finish && content.toLowerCase() === keyword_finish.toLowerCase()) {
+              const newSessions = await this.clearSessions(instance, remoteJid);
+
+              const typebotData = {
+                enabled: findTypebot.enabled,
+                url: url,
+                typebot: typebot,
+                expire: expire,
+                keyword_finish: keyword_finish,
+                delay_message: delay_message,
+                unknown_message: unknown_message,
+                listening_from_me: listening_from_me,
+                sessions: newSessions,
+              };
+
+              this.create(instance, typebotData);
+
+              return;
+            }
+
+            try {
+              const version = this.configService.get<Typebot>('TYPEBOT').API_VERSION;
+              let urlTypebot: string;
+              let reqData: {};
+              if (version === 'latest') {
+                urlTypebot = `${url}/api/v1/sessions/${data.sessionId}/continueChat`;
+                reqData = {
+                  message: content,
+                };
+              } else {
+                urlTypebot = `${url}/api/v1/sendMessage`;
+                reqData = {
+                  message: content,
+                  sessionId: data.sessionId,
+                };
+              }
+
+              const request = await axios.post(urlTypebot, reqData);
+
+              await this.sendWAMessage(
+                instance,
+                remoteJid,
+                request.data.messages,
+                request.data.input,
+                request.data.clientSideActions,
+              );
+            } catch (error) {
+              this.logger.error(error);
+              return;
+            }
+          }
+
+          return;
+        }
+      }
+
+      if (session && session.status !== 'opened') {
+        return;
+      }
+
+      if (!session) {
         const data = await this.createNewSession(instance, {
+          enabled: findTypebot.enabled,
           url: url,
           typebot: typebot,
           expire: expire,
           keyword_finish: keyword_finish,
           delay_message: delay_message,
           unknown_message: unknown_message,
+          listening_from_me: listening_from_me,
           sessions: sessions,
           remoteJid: remoteJid,
           pushName: msg.pushName,
@@ -388,103 +689,166 @@ export class TypebotService {
 
         await this.sendWAMessage(instance, remoteJid, data.messages, data.input, data.clientSideActions);
 
+        if (data.messages.length === 0) {
+          const content = this.getConversationMessage(msg.message);
+
+          if (!content) {
+            if (unknown_message) {
+              this.waMonitor.waInstances[instance.instanceName].textMessage({
+                number: remoteJid.split('@')[0],
+                options: {
+                  delay: delay_message || 1000,
+                  presence: 'composing',
+                },
+                textMessage: {
+                  text: unknown_message,
+                },
+              });
+            }
+            return;
+          }
+
+          if (keyword_finish && content.toLowerCase() === keyword_finish.toLowerCase()) {
+            sessions.splice(sessions.indexOf(session), 1);
+
+            const typebotData = {
+              enabled: findTypebot.enabled,
+              url: url,
+              typebot: typebot,
+              expire: expire,
+              keyword_finish: keyword_finish,
+              delay_message: delay_message,
+              unknown_message: unknown_message,
+              listening_from_me: listening_from_me,
+              sessions,
+            };
+
+            this.create(instance, typebotData);
+
+            return;
+          }
+
+          let request: any;
+          try {
+            const version = this.configService.get<Typebot>('TYPEBOT').API_VERSION;
+            let urlTypebot: string;
+            let reqData: {};
+            if (version === 'latest') {
+              urlTypebot = `${url}/api/v1/sessions/${data.sessionId}/continueChat`;
+              reqData = {
+                message: content,
+              };
+            } else {
+              urlTypebot = `${url}/api/v1/sendMessage`;
+              reqData = {
+                message: content,
+                sessionId: data.sessionId,
+              };
+            }
+            request = await axios.post(urlTypebot, reqData);
+
+            await this.sendWAMessage(
+              instance,
+              remoteJid,
+              request.data.messages,
+              request.data.input,
+              request.data.clientSideActions,
+            );
+          } catch (error) {
+            this.logger.error(error);
+            return;
+          }
+        }
         return;
       }
-    }
 
-    if (session && session.status !== 'opened') {
-      return;
-    }
-
-    if (!session) {
-      const data = await this.createNewSession(instance, {
-        url: url,
-        typebot: typebot,
-        expire: expire,
-        keyword_finish: keyword_finish,
-        delay_message: delay_message,
-        unknown_message: unknown_message,
-        sessions: sessions,
-        remoteJid: remoteJid,
-        pushName: msg.pushName,
+      sessions.map((session) => {
+        if (session.remoteJid === remoteJid) {
+          session.updateAt = Date.now();
+        }
       });
 
-      await this.sendWAMessage(instance, remoteJid, data.messages, data.input, data.clientSideActions);
-
-      return;
-    }
-
-    sessions.map((session) => {
-      if (session.remoteJid === remoteJid) {
-        session.updateAt = Date.now();
-      }
-    });
-
-    const typebotData = {
-      enabled: true,
-      url: url,
-      typebot: typebot,
-      expire: expire,
-      keyword_finish: keyword_finish,
-      delay_message: delay_message,
-      unknown_message: unknown_message,
-      sessions,
-    };
-
-    this.create(instance, typebotData);
-
-    const content = this.getConversationMessage(msg.message);
-
-    if (!content) {
-      if (unknown_message) {
-        this.waMonitor.waInstances[instance.instanceName].textMessage({
-          number: remoteJid.split('@')[0],
-          options: {
-            delay: delay_message || 1000,
-            presence: 'composing',
-          },
-          textMessage: {
-            text: unknown_message,
-          },
-        });
-      }
-      return;
-    }
-
-    if (content.toLowerCase() === keyword_finish.toLowerCase()) {
-      sessions.splice(sessions.indexOf(session), 1);
-
       const typebotData = {
-        enabled: true,
+        enabled: findTypebot.enabled,
         url: url,
         typebot: typebot,
         expire: expire,
         keyword_finish: keyword_finish,
         delay_message: delay_message,
         unknown_message: unknown_message,
+        listening_from_me: listening_from_me,
         sessions,
       };
 
       this.create(instance, typebotData);
 
+      const content = this.getConversationMessage(msg.message);
+
+      if (!content) {
+        if (unknown_message) {
+          this.waMonitor.waInstances[instance.instanceName].textMessage({
+            number: remoteJid.split('@')[0],
+            options: {
+              delay: delay_message || 1000,
+              presence: 'composing',
+            },
+            textMessage: {
+              text: unknown_message,
+            },
+          });
+        }
+        return;
+      }
+
+      if (keyword_finish && content.toLowerCase() === keyword_finish.toLowerCase()) {
+        sessions.splice(sessions.indexOf(session), 1);
+
+        const typebotData = {
+          enabled: findTypebot.enabled,
+          url: url,
+          typebot: typebot,
+          expire: expire,
+          keyword_finish: keyword_finish,
+          delay_message: delay_message,
+          unknown_message: unknown_message,
+          listening_from_me: listening_from_me,
+          sessions,
+        };
+
+        this.create(instance, typebotData);
+
+        return;
+      }
+
+      const version = this.configService.get<Typebot>('TYPEBOT').API_VERSION;
+      let urlTypebot: string;
+      let reqData: {};
+      if (version === 'latest') {
+        urlTypebot = `${url}/api/v1/sessions/${session.sessionId.split('-')[1]}/continueChat`;
+        reqData = {
+          message: content,
+        };
+      } else {
+        urlTypebot = `${url}/api/v1/sendMessage`;
+        reqData = {
+          message: content,
+          sessionId: session.sessionId.split('-')[1],
+        };
+      }
+      const request = await axios.post(urlTypebot, reqData);
+
+      await this.sendWAMessage(
+        instance,
+        remoteJid,
+        request.data.messages,
+        request.data.input,
+        request.data.clientSideActions,
+      );
+
+      return;
+    } catch (error) {
+      this.logger.error(error);
       return;
     }
-
-    const reqData = {
-      message: content,
-      sessionId: session.sessionId.split('-')[1],
-    };
-
-    const request = await axios.post(url + '/api/v1/sendMessage', reqData);
-
-    await this.sendWAMessage(
-      instance,
-      remoteJid,
-      request.data.messages,
-      request.data.input,
-      request.data.clientSideActions,
-    );
-
-    return;
   }
 }

src/whatsapp/services/webhook.service.ts

@@ -26,7 +26,7 @@ export class WebhookService {
 
       return result;
     } catch (error) {
-      return { enabled: false, url: '', events: [], webhook_by_events: false };
+      return { enabled: false, url: '', events: [], webhook_by_events: false, webhook_base64: false };
     }
   }
 }

src/whatsapp/types/wa.types.ts

@@ -3,6 +3,8 @@ import { AuthenticationState, WAConnectionState } from '@whiskeysockets/baileys'
 
 export enum Events {
   APPLICATION_STARTUP = 'application.startup',
+  INSTANCE_CREATE = 'instance.create',
+  INSTANCE_DELETE = 'instance.delete',
   QRCODE_UPDATED = 'qrcode.updated',
   CONNECTION_UPDATE = 'connection.update',
   STATUS_INSTANCE = 'status.instance',
@@ -23,6 +25,9 @@ export enum Events {
   GROUPS_UPDATE = 'groups.update',
   GROUP_PARTICIPANTS_UPDATE = 'group-participants.update',
   CALL = 'call',
+  TYPEBOT_START = 'typebot.start',
+  TYPEBOT_CHANGE_STATUS = 'typebot.change-status',
+  CHAMA_AI_ACTION = 'chama-ai.action',
 }
 
 export declare namespace wa {
@@ -47,6 +52,7 @@ export declare namespace wa {
     url?: string;
     events?: string[];
     webhook_by_events?: boolean;
+    webhook_base64?: boolean;
   };
 
   export type LocalChatwoot = {
@@ -80,6 +86,11 @@ export declare namespace wa {
     events?: string[];
   };
 
+  export type LocalSqs = {
+    enabled?: boolean;
+    events?: string[];
+  };
+
   type Session = {
     remoteJid?: string;
     sessionId?: string;
@@ -94,6 +105,7 @@ export declare namespace wa {
     keyword_finish?: string;
     delay_message?: number;
     unknown_message?: string;
+    listening_from_me?: boolean;
     sessions?: Session[];
   };
 
@@ -102,6 +114,14 @@ export declare namespace wa {
     proxy?: string;
   };
 
+  export type LocalChamaai = {
+    enabled?: boolean;
+    url?: string;
+    token?: string;
+    waNumber?: string;
+    answerByAudio?: boolean;
+  };
+
   export type StateConnection = {
     instance?: string;
     state?: WAConnectionState | 'refused';

src/whatsapp/whatsapp.module.ts

@@ -3,6 +3,7 @@ import { eventEmitter } from '../config/event.config';
 import { Logger } from '../config/logger.config';
 import { dbserver } from '../libs/db.connect';
 import { RedisCache } from '../libs/redis.client';
+import { ChamaaiController } from './controllers/chamaai.controller';
 import { ChatController } from './controllers/chat.controller';
 import { ChatwootController } from './controllers/chatwoot.controller';
 import { GroupController } from './controllers/group.controller';
@@ -11,12 +12,13 @@ import { ProxyController } from './controllers/proxy.controller';
 import { RabbitmqController } from './controllers/rabbitmq.controller';
 import { SendMessageController } from './controllers/sendMessage.controller';
 import { SettingsController } from './controllers/settings.controller';
+import { SqsController } from './controllers/sqs.controller';
 import { TypebotController } from './controllers/typebot.controller';
-import { ViewsController } from './controllers/views.controller';
 import { WebhookController } from './controllers/webhook.controller';
 import { WebsocketController } from './controllers/websocket.controller';
 import {
   AuthModel,
+  ChamaaiModel,
   ChatModel,
   ChatwootModel,
   ContactModel,
@@ -25,11 +27,13 @@ import {
   ProxyModel,
   RabbitmqModel,
   SettingsModel,
+  SqsModel,
   TypebotModel,
   WebhookModel,
   WebsocketModel,
 } from './models';
 import { AuthRepository } from './repository/auth.repository';
+import { ChamaaiRepository } from './repository/chamaai.repository';
 import { ChatRepository } from './repository/chat.repository';
 import { ChatwootRepository } from './repository/chatwoot.repository';
 import { ContactRepository } from './repository/contact.repository';
@@ -39,15 +43,18 @@ import { ProxyRepository } from './repository/proxy.repository';
 import { RabbitmqRepository } from './repository/rabbitmq.repository';
 import { RepositoryBroker } from './repository/repository.manager';
 import { SettingsRepository } from './repository/settings.repository';
+import { SqsRepository } from './repository/sqs.repository';
 import { TypebotRepository } from './repository/typebot.repository';
 import { WebhookRepository } from './repository/webhook.repository';
 import { WebsocketRepository } from './repository/websocket.repository';
 import { AuthService } from './services/auth.service';
+import { ChamaaiService } from './services/chamaai.service';
 import { ChatwootService } from './services/chatwoot.service';
 import { WAMonitoringService } from './services/monitor.service';
 import { ProxyService } from './services/proxy.service';
 import { RabbitmqService } from './services/rabbitmq.service';
 import { SettingsService } from './services/settings.service';
+import { SqsService } from './services/sqs.service';
 import { TypebotService } from './services/typebot.service';
 import { WebhookService } from './services/webhook.service';
 import { WebsocketService } from './services/websocket.service';
@@ -62,7 +69,9 @@ const typebotRepository = new TypebotRepository(TypebotModel, configService);
 const webhookRepository = new WebhookRepository(WebhookModel, configService);
 const websocketRepository = new WebsocketRepository(WebsocketModel, configService);
 const proxyRepository = new ProxyRepository(ProxyModel, configService);
+const chamaaiRepository = new ChamaaiRepository(ChamaaiModel, configService);
 const rabbitmqRepository = new RabbitmqRepository(RabbitmqModel, configService);
+const sqsRepository = new SqsRepository(SqsModel, configService);
 const chatwootRepository = new ChatwootRepository(ChatwootModel, configService);
 const settingsRepository = new SettingsRepository(SettingsModel, configService);
 const authRepository = new AuthRepository(AuthModel, configService);
@@ -77,8 +86,10 @@ export const repository = new RepositoryBroker(
   settingsRepository,
   websocketRepository,
   rabbitmqRepository,
+  sqsRepository,
   typebotRepository,
   proxyRepository,
+  chamaaiRepository,
   authRepository,
   configService,
   dbserver?.getClient(),
@@ -90,7 +101,7 @@ export const waMonitor = new WAMonitoringService(eventEmitter, configService, re
 
 const authService = new AuthService(configService, waMonitor, repository);
 
-const typebotService = new TypebotService(waMonitor);
+const typebotService = new TypebotService(waMonitor, configService, eventEmitter);
 
 export const typebotController = new TypebotController(typebotService);
 
@@ -106,13 +117,21 @@ const proxyService = new ProxyService(waMonitor);
 
 export const proxyController = new ProxyController(proxyService);
 
+const chamaaiService = new ChamaaiService(waMonitor, configService);
+
+export const chamaaiController = new ChamaaiController(chamaaiService);
+
 const rabbitmqService = new RabbitmqService(waMonitor);
 
 export const rabbitmqController = new RabbitmqController(rabbitmqService);
 
-const chatwootService = new ChatwootService(waMonitor, configService);
+const sqsService = new SqsService(waMonitor);
 
-export const chatwootController = new ChatwootController(chatwootService, configService);
+export const sqsController = new SqsController(sqsService);
+
+const chatwootService = new ChatwootService(waMonitor, configService, repository);
+
+export const chatwootController = new ChatwootController(chatwootService, configService, repository);
 
 const settingsService = new SettingsService(waMonitor);
 
@@ -129,10 +148,11 @@ export const instanceController = new InstanceController(
   settingsService,
   websocketService,
   rabbitmqService,
+  proxyService,
+  sqsService,
   typebotService,
   cache,
 );
-export const viewsController = new ViewsController(waMonitor, configService);
 export const sendMessageController = new SendMessageController(waMonitor);
 export const chatController = new ChatController(waMonitor);
 export const groupController = new GroupController(waMonitor);

views/manager-wip.hbs

@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html lang="pt-br">
+
+<head>
+   <meta charset="UTF-8">
+   <meta http-equiv="X-UA-Compatible" content="IE=edge">
+   <meta name="viewport" content="width=device-width, initial-scale=1.0">
+   <link rel="shortcut icon" href="https://evolution-api.com/files/evolution-api-favicon.png" type="image/x-icon">
+
+   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.6.2/dist/css/bootstrap.min.css"
+      integrity="sha384-xOolHFLEh07PJGoPkLv1IbcEPTNtaed2xpHsD9ESMhqIYd0nLMwNLD69Npy4HI+N" crossorigin="anonymous">
+   <title>Instance Manager</title>
+</head>
+
+<body>
+   <div class="container mt-4">
+      <!-- Botão para abrir o modal de adicionar nova instância -->
+      <button class="btn btn-primary mb-3" data-toggle="modal" data-target="#actionModal" data-action="add">Nova
+         Instância</button>
+
+      <!-- Tabela de instâncias -->
+      <table class="table table-bordered">
+         <thead>
+            <tr>
+               <th>Nome da Instância</th>
+               <th>Status</th>
+               <th>API Key</th>
+               <th>Ações</th>
+            </tr>
+         </thead>
+         <tbody>
+            <!-- Iterando sobre as instâncias e preenchendo a tabela -->
+            {{#each instances}}
+            <tr>
+               <td>{{this.instance.instanceName}}</td>
+               <td>{{this.instance.status}}</td>
+               <td>{{this.instance.apikey}}</td>
+               <td>
+                  <!-- Dropdown de ações para cada instância -->
+                  <div class="dropdown">
+                     <button class="btn btn-secondary dropdown-toggle" type="button" id="actionDropdown"
+                        data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
+                        Ações
+                     </button>
+                     <div class="dropdown-menu" aria-labelledby="actionDropdown">
+                        <a class="dropdown-item" href="#" data-toggle="modal" data-target="#actionModal"
+                           data-action="connect">Connect</a>
+                        <a class="dropdown-item" href="#" data-toggle="modal" data-target="#actionModal"
+                           data-action="restart">Restart</a>
+                        <!-- Adicione mais itens de ação aqui -->
+                        <!-- ... -->
+                     </div>
+                  </div>
+               </td>
+            </tr>
+            {{/each}}
+         </tbody>
+      </table>
+   </div>
+
+   <!-- Modal de ações -->
+   <div class="modal fade" id="actionModal" tabindex="-1" role="dialog" aria-labelledby="actionModalLabel"
+      aria-hidden="true">
+      <div class="modal-dialog" role="document">
+         <div class="modal-content">
+            <div class="modal-header">
+               <h5 class="modal-title" id="actionModalLabel">Ação</h5>
+               <button type="button" class="close" data-dismiss="modal" aria-label="Close">
+                  <span aria-hidden="true">&times;</span>
+               </button>
+            </div>
+            <div class="modal-body">
+            </div>
+            <div class="modal-footer">
+               <button type="button" class="btn btn-secondary" data-dismiss="modal">Fechar</button>
+               <button type="button" class="btn btn-primary">Salvar</button>
+            </div>
+         </div>
+      </div>
+   </div>
+
+   <script src="https://cdn.jsdelivr.net/npm/jquery@3.5.1/dist/jquery.slim.min.js"
+      integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj"
+      crossorigin="anonymous"></script>
+   <script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.1/dist/umd/popper.min.js"
+      integrity="sha384-9/reFTGAW83EW2RDu2S0VKaIzap3H66lZH81PoYlFhbGU+6BZp6G7niu735Sk7lN"
+      crossorigin="anonymous"></script>
+   <script src="https://cdn.jsdelivr.net/npm/bootstrap@4.6.2/dist/js/bootstrap.min.js"
+      integrity="sha384-+sLIOodYLS7CIrQpBjl+C7nPvqq+FbNUBDunl/OZv93DB7Ln/533i8e/mZXLi/P+"
+      crossorigin="anonymous"></script>
+
+   <script>
+      $(document).ready(function(){
+         $('#actionModal').on('show.bs.modal', function(event) {
+         var button = $(event.relatedTarget);
+         var action = button.data('action');
+
+         console.log(action);
+
+         if (action === 'connect') {
+            
+         } else if (action === 'restart') {
+            
+         }
+      });
+      })
+   </script>
+</body>
+
+</html>

views/manager.hbs

@@ -11,7 +11,7 @@
 
 <body>
 
-   <iframe src="https://app.smith.dgcode.com.br/app/evolutionapi-public/home-64ca60783615e270291978b4?embed=true" frameborder="0" style="width: 100%; height: 100vh;"></iframe>
+   <iframe src="https://manager.evolution-api.com" frameborder="0" style="width: 100%; height: 100vh;"></iframe>
    
 </body>