[core] Fix lint

fix #1397

.env.example

@@ -8,6 +8,7 @@
 # ==================
 # Base URL for the API (used for webhooks, file URLs, etc.)
 WAHA_BASE_URL=http://localhost:3000
+# WAHA_PUBLIC_URL=http://localhost:3000
 
 # Server configuration (if you need to customize hostname/port)
 # WHATSAPP_API_SCHEMA=http

Makefile

@@ -35,13 +35,13 @@ for-swagger:
 	WHATSAPP_SWAGGER_CONFIG_ADVANCED=true . ${NVM_DIR}/nvm.sh && nvm exec yarn start
 
 up-noweb:
-	. ${NVM_DIR}/nvm.sh && nvm exec yarn up @adiwajshing/baileys@github:devlikeapro/Baileys#fork-master-2025-09-21
+	yarn up @adiwajshing/baileys@github:devlikeapro/Baileys#fork-master-2025-10-03
 
 up-noweb-libsignal:
-	. ${NVM_DIR}/nvm.sh && nvm exec yarn up libsignal@github:devlikeapro/libsignal-node#fork-master
+	yarn up libsignal@github:devlikeapro/libsignal-node#fork-master
 
 up-webjs:
-	. ${NVM_DIR}/nvm.sh && nvm exec yarn up whatsapp-web.js@github:devlikeapro/whatsapp-web.js#fork-main-2025-09-10
+	yarn up whatsapp-web.js@github:devlikeapro/whatsapp-web.js#fork-main-2025-09-10
 
 start-proxy:
 	docker run --rm -d --name squid-container -e TZ=UTC -p 3128:3128 ubuntu/squid:5.2-22.04_beta

docker-compose/chatwoot/.chatwoot.env

@@ -1,6 +1,10 @@
 # Learn about the various environment variables at
 # https://www.chatwoot.com/docs/self-hosted/configuration/environment-variables/#rails-production-variables
 
+# Increase rack default timeout (30s) to avoid timeout errors
+# Workaround for https://github.com/devlikeapro/waha/issues/1389
+RACK_TIMEOUT_SERVICE_TIMEOUT=60
+
 # Used to verify the integrity of signed cookies. so ensure a secure value is set
 # SECRET_KEY_BASE should be alphanumeric. Avoid special characters or symbols. 
 # Use `rake secret` to generate this variable

docker-compose/chatwoot/.waha.env

@@ -8,6 +8,7 @@
 # ==================
 # Base URL for the API (used for webhooks, file URLs, etc.)
 WAHA_BASE_URL=http://waha:3000
+WAHA_PUBLIC_URL=http://localhost:3000
 
 # Server configuration (if you need to customize hostname/port)
 # WHATSAPP_API_SCHEMA=http

package.json

@@ -26,7 +26,7 @@
     "gows:proto": "yarn gows:proto:fetch && yarn gows:proto:build"
   },
   "dependencies": {
-    "@adiwajshing/baileys": "github:devlikeapro/Baileys#fork-master-2025-09-21",
+    "@adiwajshing/baileys": "github:devlikeapro/Baileys#fork-master-2025-10-03",
     "@adiwajshing/keyed-db": "^0.2.4",
     "@aws-sdk/client-s3": "^3.633.0",
     "@aws-sdk/s3-request-presigner": "^3.633.0",

src/apps/app_sdk/JobUtils.ts

@@ -51,10 +51,17 @@ export function HasBeenRetried(job: Job): boolean {
   return attemptsMade > 1;
 }
 
+let base =
+  process.env.WAHA_PUBLIC_URL ||
+  process.env.WAHA_BASE_URL ||
+  'http://localhost:3000';
+// cut / at the end
+base = base.replace(/\/+$/, '');
+
 export function JobLink(job: Job): { text: string; url: string } {
   const text = `${job.queueName} => ${job.id}`;
-  const url = `http://localhost:3000/jobs/queue/${encodeURIComponent(
-    job.queueName,
-  )}/${job.id}`;
+  const url = `${base}/jobs/queue/${encodeURIComponent(job.queueName)}/${
+    job.id
+  }`;
   return { text: text, url: url };
 }

src/apps/app_sdk/auth.ts

@@ -4,12 +4,12 @@ import { parseBool } from '@waha/helpers';
 import * as basicAuth from 'express-basic-auth';
 
 export function BullAuthMiddleware() {
-  let username = process.env.WAHA_DASHBOARD_USERNAME;
-  let password = process.env.WAHA_DASHBOARD_PASSWORD;
+  let username = process.env.WAHA_DASHBOARD_USERNAME || '';
+  let password = process.env.WAHA_DASHBOARD_PASSWORD || '';
   if (process.env.WAHA_DASHBOARD_ENABLED) {
     const enabled = parseBool(process.env.WAHA_DASHBOARD_ENABLED);
     if (!enabled) {
-      // Generate a random uuid4 username /password to prevent access
+      // Generate a random uuid4 username/password to effectively disable access
       username = 'admin';
       password = crypto.randomUUID();
     }
@@ -18,7 +18,7 @@ export function BullAuthMiddleware() {
   return basicAuth({
     challenge: true,
     users: {
-      [username]: password,
+      [String(username)]: String(password),
     },
   });
 }

src/apps/app_sdk/dto/app.dto.ts

@@ -7,7 +7,7 @@ import {
   IsString,
   ValidateNested,
 } from 'class-validator';
-import { ApiProperty } from '@nestjs/swagger';
+import { ApiExtraModels, ApiProperty } from '@nestjs/swagger';
 
 export type AllowedAppConfig = ChatWootAppConfig;
 
@@ -15,6 +15,7 @@ export enum AppName {
   chatwoot = 'chatwoot',
 }
 
+@ApiExtraModels(ChatWootAppConfig)
 export class App<T extends AllowedAppConfig = any> {
   @IsString()
   id: string;

src/apps/app_sdk/services/AppsDisabledService.ts

@@ -44,4 +44,8 @@ export class AppsDisabledService implements IAppsService {
   async beforeSessionStart(session: WhatsappSession, store: DataStore) {
     return;
   }
+
+  async afterSessionStart(session: WhatsappSession, store: DataStore) {
+    return;
+  }
 }

src/apps/app_sdk/services/AppsEnabledService.ts

@@ -145,7 +145,17 @@ export class AppsEnabledService implements IAppsService {
     const apps = await repo.getEnabledBySession(session.name);
     for (const app of apps) {
       const service = this.getAppService(app);
-      await service.beforeSessionStart(app, session);
+      service.beforeSessionStart(app, session);
+    }
+  }
+
+  async afterSessionStart(session: WhatsappSession, store: DataStore) {
+    const knex = store.getWAHADatabase();
+    const repo = new AppRepository(knex);
+    const apps = await repo.getEnabledBySession(session.name);
+    for (const app of apps) {
+      const service = this.getAppService(app);
+      service.afterSessionStart(app, session);
     }
   }
 

src/apps/app_sdk/services/IAppService.ts

@@ -23,5 +23,7 @@ export interface IAppService {
 
   beforeDeleted(app: App): Promise<void>;
 
-  beforeSessionStart(app: App, session: WhatsappSession): Promise<void>;
+  beforeSessionStart(app: App, session: WhatsappSession): void;
+
+  afterSessionStart(app: App, session: WhatsappSession): void;
 }

src/apps/app_sdk/services/IAppsService.ts

@@ -17,6 +17,8 @@ export interface IAppsService {
 
   beforeSessionStart(session: WhatsappSession, store: DataStore): Promise<void>;
 
+  afterSessionStart(session: WhatsappSession, store: DataStore): Promise<void>;
+
   migrate(knex: Knex): Promise<void>;
 }
 

src/apps/chatwoot/api/chatwoot.webhook.controller.ts

@@ -89,6 +89,7 @@ export class ChatwootWebhookController {
         return { success: true };
       default:
         // Ignore other events
+        await this.chatWootQueueService.addJobToQueue(body.event, data);
         return { success: true };
     }
   }

src/apps/chatwoot/cache/ConversationCache.ts

@@ -1,8 +1,7 @@
-import { public_conversation } from '@figuro/chatwoot-sdk';
 import { ChatWootAPIConfig } from '@waha/apps/chatwoot/client/interfaces';
 import * as NodeCache from 'node-cache';
 
-import { IConversationCache } from './IConversationCache';
+import { ConversationId, IConversationCache } from './IConversationCache';
 
 const cache: NodeCache = new NodeCache({
   stdTTL: 24 * 60 * 60, // 1 day
@@ -16,7 +15,7 @@ export function CacheForConfig(config: ChatWootAPIConfig): ConversationCache {
 class ConversationCache implements IConversationCache {
   constructor(private prefix: string) {}
 
-  fullKey(key: string) {
+  private fullKey(key: string) {
     return `${this.prefix}.${key}`;
   }
 
@@ -25,7 +24,7 @@ class ConversationCache implements IConversationCache {
     cache.del(fullKey);
   }
 
-  get(key: string): public_conversation | null {
+  get(key: string): ConversationId | null {
     const fullKey = this.fullKey(key);
     return cache.get(fullKey) || null;
   }
@@ -35,7 +34,7 @@ class ConversationCache implements IConversationCache {
     return cache.has(fullKey);
   }
 
-  set(key: string, value: public_conversation): void {
+  set(key: string, value: ConversationId): void {
     const fullKey = this.fullKey(key);
     cache.set(fullKey, value);
   }

src/apps/chatwoot/cache/IConversationCache.ts

@@ -1,8 +1,8 @@
-import { public_conversation } from '@figuro/chatwoot-sdk';
+export type ConversationId = number;
 
 export interface IConversationCache {
-  get(key: string): public_conversation | null;
-  set(key: string, value: public_conversation): void;
+  get(key: string): ConversationId | null;
+  set(key: string, value: ConversationId): void;
   has(key: string): boolean;
   delete(key: string): void;
   clean(): void;

src/apps/chatwoot/chatwoot.module.ts

@@ -25,6 +25,8 @@ import { WAHASessionStatusConsumer } from './consumers/waha/session.status';
 import { ChatWootQueueService } from './services/ChatWootQueueService';
 import { ChatWootScheduleService } from './services/ChatWootScheduleService';
 import { ChatWootWAHAQueueService } from './services/ChatWootWAHAQueueService';
+import { ChatWootConversationCreatedConsumer } from './consumers/inbox/conversation_created';
+import { ChatWootConversationStatusChangedConsumer } from '@waha/apps/chatwoot/consumers/inbox/conversation_status_changed';
 
 const CONTROLLERS = [ChatwootWebhookController, ChatwootLocalesController];
 
@@ -65,6 +67,14 @@ const IMPORTS = lodash.flatten([
     name: QueueName.INBOX_MESSAGE_UPDATED,
     defaultJobOptions: merge(ExponentialRetriesJobOptions, JobRemoveOptions),
   }),
+  RegisterAppQueue({
+    name: QueueName.INBOX_CONVERSATION_CREATED,
+    defaultJobOptions: merge(NoRetriesJobOptions, JobRemoveOptions),
+  }),
+  RegisterAppQueue({
+    name: QueueName.INBOX_CONVERSATION_STATUS_CHANGED,
+    defaultJobOptions: merge(NoRetriesJobOptions, JobRemoveOptions),
+  }),
   RegisterAppQueue({
     name: QueueName.INBOX_MESSAGE_DELETED,
     defaultJobOptions: merge(ExponentialRetriesJobOptions, JobRemoveOptions),
@@ -79,6 +89,9 @@ const PROVIDERS = [
   ChatWootInboxMessageCreatedConsumer,
   ChatWootInboxMessageUpdatedConsumer,
   ChatWootInboxMessageDeletedConsumer,
+  // Conversation events
+  ChatWootConversationCreatedConsumer,
+  ChatWootConversationStatusChangedConsumer,
   ChatWootInboxCommandsConsumer,
   WAHASessionStatusConsumer,
   WAHAMessageAnyConsumer,

src/apps/chatwoot/client/ContactConversationService.ts

@@ -1,18 +1,20 @@
 import ChatwootClient, {
-  ApiError,
+  ApiError as ChatWootAPIError,
   public_contact_create_update_payload,
-  public_conversation,
 } from '@figuro/chatwoot-sdk';
 import { ILogger } from '@waha/apps/app_sdk/ILogger';
-import { ContactAPI } from '@waha/apps/chatwoot/client/ContactAPI';
+import { ContactService } from '@waha/apps/chatwoot/client/ContactService';
 import { Conversation } from '@waha/apps/chatwoot/client/Conversation';
-import { ConversationAPI } from '@waha/apps/chatwoot/client/ConversationAPI';
+import { ConversationService } from '@waha/apps/chatwoot/client/ConversationService';
 import { ChatWootAPIConfig } from '@waha/apps/chatwoot/client/interfaces';
 import { InboxContactInfo } from '@waha/apps/chatwoot/contacts/InboxContactInfo';
 import { Locale } from '@waha/apps/chatwoot/i18n/locale';
 
 import { CacheForConfig } from '../cache/ConversationCache';
-import { IConversationCache } from '../cache/IConversationCache';
+import {
+  ConversationId,
+  IConversationCache,
+} from '../cache/IConversationCache';
 
 export interface ContactInfo {
   ChatId(): string;
@@ -29,8 +31,8 @@ export class ContactConversationService {
 
   constructor(
     private config: ChatWootAPIConfig,
-    private contactAPI: ContactAPI,
-    private conversationAPI: ConversationAPI,
+    private contactService: ContactService,
+    private conversationService: ConversationService,
     private accountAPI: ChatwootClient,
     private logger: ILogger,
     private l: Locale,
@@ -40,7 +42,7 @@ export class ContactConversationService {
 
   private async upsertByContactInfo(
     contactInfo: ContactInfo,
-  ): Promise<public_conversation> {
+  ): Promise<ConversationId> {
     const chatId = contactInfo.ChatId();
 
     // Check cache for chat id
@@ -51,61 +53,70 @@ export class ContactConversationService {
     //
     // Find or create contact
     //
-    let contact = await this.contactAPI.searchByAnyID(chatId);
+    let contact = await this.contactService.searchByAnyID(chatId);
     if (!contact) {
       const request = await contactInfo.PublicContactCreate();
-      contact = await this.contactAPI.create(chatId, request);
+      contact = await this.contactService.create(chatId, request);
     }
 
     // Update custom attributes - always
     const attributes = await contactInfo.Attributes();
     this.logger.info(
-      `Updating contact custom attributes for chat.id: ${chatId}, contact.id: ${contact.data.id}`,
+      `Updating if required contact custom attributes for chat.id: ${chatId}, contact.id: ${contact.data.id}`,
     );
-    await this.contactAPI.updateCustomAttributes(contact.data, attributes);
+    await this.contactService.upsertCustomAttributes(contact.data, attributes);
 
     // Update Avatar if nothing, but keep the original one if any
     if (!contact.data.thumbnail) {
-      const avatarUrl = await contactInfo.AvatarUrl();
+      const avatarUrl = await contactInfo.AvatarUrl().catch((err) => {
+        this.logger.warn(
+          `Error getting avatar for chat.id from WhatsApp: ${chatId}`,
+        );
+        this.logger.warn(err);
+        return null;
+      });
       if (avatarUrl) {
-        this.contactAPI.updateAvatarUrlSafe(contact.data.id, avatarUrl);
+        this.contactService.updateAvatarUrlSafe(contact.data.id, avatarUrl);
       }
     }
 
     this.logger.info(
-      `Using contact for chat.id: ${chatId}, contact.id: ${contact.sourceId}`,
+      `Using contact for chat.id: ${chatId}, contact.id: ${contact.data.id}, contact.sourceId: ${contact.sourceId}`,
     );
 
     //
     // Get or create a conversation for this inbox
     //
-    const conversation = await this.conversationAPI.upsert(contact.sourceId);
+    const conversation = await this.conversationService.upsert({
+      id: contact.data.id,
+      sourceId: contact.sourceId,
+    });
     this.logger.info(
       `Using conversation for chat.id: ${chatId}, conversation.id: ${conversation.id}, contact.id: ${contact.sourceId}`,
     );
 
     // Save to cache
-    this.cache.set(chatId, conversation);
-    return conversation;
+    this.cache.set(chatId, conversation.id);
+    return conversation.id;
   }
 
   public async ConversationByContact(
     contactInfo: ContactInfo,
   ): Promise<Conversation> {
     const chatId = contactInfo.ChatId();
-    const publicConversation = await this.upsertByContactInfo(contactInfo);
+    const conversationId = await this.upsertByContactInfo(contactInfo);
     const conversation = new Conversation(
       this.accountAPI,
       this.config.accountId,
-      publicConversation.id,
+      conversationId,
     );
     conversation.onError = (err) => {
-      if (err instanceof ApiError) {
+      if (err instanceof ChatWootAPIError) {
         // invalidate cache
         this.cache.delete(chatId);
         this.logger.error(`ApiError: ${err.message}`);
         this.logger.error(
-          `ApiError occurred, invalidating cache for chat.id: ${chatId}, conversation.id: ${publicConversation.id}`,
+          `ApiError occurred, invalidating cache for chat.id: ${chatId}, conversation.id: ${conversationId}`,
         );
       }
     };
@@ -127,4 +138,26 @@ export class ContactConversationService {
   public async InboxNotifications() {
     return this.ConversationByContact(new InboxContactInfo(this.l));
   }
+
+  public ResetCache(chatIds: Array<string>) {
+    this.logger.info(`Resetting cache chat ids: ${chatIds.join(', ')}`);
+    for (const chatId of chatIds) {
+      this.cache.delete(chatId);
+    }
+  }
+
+  public ResetMismatchedCache(chatIds: Array<string>, value: ConversationId) {
+    for (const chatId of chatIds) {
+      if (!this.cache.has(chatId)) {
+        continue;
+      }
+      const current = this.cache.get(chatId);
+      if (current !== value) {
+        this.logger.info(
+          `Resetting cache for chat id: ${chatId}, value changed from ${current} to ${value}`,
+        );
+        this.cache.delete(chatId);
+      }
+    }
+  }
 }

src/apps/chatwoot/client/ContactService.ts

@@ -13,13 +13,14 @@ import { isJidCusFormat } from '@waha/utils/wa';
 import * as lodash from 'lodash';
 
 import { AttributeKey } from '../const';
+import { E164Parser } from '@waha/core/utils/PhoneJidNormalizer';
 
 export interface ContactResponse {
   data: generic_id & contact;
   sourceId: string;
 }
 
-export class ContactAPI {
+export class ContactService {
   constructor(
     private config: ChatWootAPIConfig,
     private accountAPI: ChatwootClient,
@@ -64,8 +65,8 @@ export class ContactAPI {
 
     if (isJidCusFormat(chatId)) {
       // Search by phone
-      let phone_number = chatId.split('@')[0];
-      phone_number = phone_number.replace('+', '');
+      const phoneNumberE164 = E164Parser.fromJid(chatId);
+      const phone_number = phoneNumberE164.replace('+', '');
       payload[payload.length - 1].query_operator = 'OR';
       payload.push({
         attribute_key: 'phone_number',
@@ -96,18 +97,22 @@ export class ContactAPI {
     };
   }
 
-  public updateCustomAttributes(
+  public async upsertCustomAttributes(
     contact: generic_id & contact,
     attributes: any,
-  ) {
+  ): Promise<boolean> {
+    if (lodash.isEqual(attributes, contact.custom_attributes)) {
+      return false;
+    }
     const update: contact_update = {
       custom_attributes: { ...contact.custom_attributes, ...attributes },
     };
-    return this.accountAPI.contacts.update({
+    await this.accountAPI.contacts.update({
       id: contact.id,
       accountId: this.config.accountId,
       data: update,
     });
+    return true;
   }
 
   public async create(
@@ -142,7 +147,7 @@ export class ContactAPI {
       })
       .catch((e) => {
         this.logger.warn(
-          'Error updating avatar_url for contact.id: ' + contactId,
+          `Error updating avatar_url for contact.id: ${contactId}`,
         );
         this.logger.warn(e);
       });

src/apps/chatwoot/client/ConversationAPI.ts

@@ -1,52 +0,0 @@
-import { public_conversation } from '@figuro/chatwoot-sdk';
-import { ILogger } from '@waha/apps/app_sdk/ILogger';
-import {
-  ChatWootAPIConfig,
-  ChatWootInboxAPI,
-} from '@waha/apps/chatwoot/client/interfaces';
-
-export class ConversationAPI {
-  constructor(
-    private config: ChatWootAPIConfig,
-    private inboxAPI: ChatWootInboxAPI,
-    private logger: ILogger,
-  ) {}
-
-  private async find(
-    contactIdentifier: string,
-  ): Promise<public_conversation | null> {
-    const request = {
-      inboxIdentifier: this.config.inboxIdentifier,
-      contactIdentifier: contactIdentifier,
-    };
-    const conversations = await this.inboxAPI.conversations.list(request);
-    if (conversations.length != 0) {
-      return conversations[0];
-    }
-    return null;
-  }
-
-  private async create(
-    contactIdentifier: string,
-  ): Promise<public_conversation> {
-    const conversation = await this.inboxAPI.conversations.create({
-      inboxIdentifier: this.config.inboxIdentifier,
-      contactIdentifier: contactIdentifier,
-    });
-    this.logger.info(
-      `Created conversation.id: ${conversation.id} for contact.id: ${contactIdentifier}`,
-    );
-    return conversation;
-  }
-
-  async upsert(contactIdentifier: string): Promise<public_conversation> {
-    let conversation = await this.find(contactIdentifier);
-    if (!conversation) {
-      conversation = await this.create(contactIdentifier);
-    }
-    this.logger.info(
-      `Using conversation.id: ${conversation.id} for contact.id: ${contactIdentifier}`,
-    );
-    return conversation;
-  }
-}

src/apps/chatwoot/client/ConversationService.ts

@@ -0,0 +1,57 @@
+import ChatwootClient, { contact_conversations } from '@figuro/chatwoot-sdk';
+import { ILogger } from '@waha/apps/app_sdk/ILogger';
+import {
+  ChatWootAPIConfig,
+  ChatWootInboxAPI,
+} from '@waha/apps/chatwoot/client/interfaces';
+import type { conversation } from '@figuro/chatwoot-sdk/dist/models/conversation';
+import { ConversationSelector } from '@waha/apps/chatwoot/services/ConversationSelector';
+
+export type ConversationResult = Pick<conversation, 'id' | 'account_id'>;
+
+export interface ContactIds {
+  id: number;
+  sourceId: string;
+}
+
+export class ConversationService {
+  constructor(
+    private config: ChatWootAPIConfig,
+    private accountAPI: ChatwootClient,
+    private inboxAPI: ChatWootInboxAPI,
+    private selector: ConversationSelector,
+    private logger: ILogger,
+  ) {}
+
+  private async find(contact: ContactIds): Promise<ConversationResult | null> {
+    const result: { payload: contact_conversations } =
+      (await this.accountAPI.contacts.listConversations({
+        accountId: this.config.accountId,
+        id: contact.id,
+      })) as any;
+    const conversations = result.payload;
+    return this.selector.select(conversations);
+  }
+
+  private async create(contact: ContactIds): Promise<ConversationResult> {
+    const conversation = await this.inboxAPI.conversations.create({
+      inboxIdentifier: this.config.inboxIdentifier,
+      contactIdentifier: contact.sourceId,
+    });
+    this.logger.info(
+      `Created conversation.id: ${conversation.id} for contact.id: ${contact.id}, contact.sourceId: ${contact.sourceId}`,
+    );
+    return conversation;
+  }
+
+  async upsert(contact: ContactIds): Promise<ConversationResult> {
+    let conversation = await this.find(contact);
+    if (!conversation) {
+      conversation = await this.create(contact);
+    }
+    this.logger.info(
+      `Using conversation.id: ${conversation.id} for contact.id: ${contact.id}, contact.sourceId: ${contact.sourceId}`,
+    );
+    return conversation;
+  }
+}

src/apps/chatwoot/client/CustomAttributesAPI.ts

@@ -1,53 +0,0 @@
-import ChatwootClient from '@figuro/chatwoot-sdk';
-import { ChatWootAccountAPIConfig } from '@waha/apps/chatwoot/client/interfaces';
-import {
-  CustomAttributeModel,
-  CustomAttributeType,
-} from '@waha/apps/chatwoot/client/types';
-
-export interface CustomAttribute {
-  key: string;
-  name: string;
-  type: CustomAttributeType;
-  description: string;
-  model: CustomAttributeModel;
-}
-
-export class CustomAttributesAPI {
-  constructor(
-    private config: ChatWootAccountAPIConfig,
-    private accountAPI: ChatwootClient,
-  ) {}
-
-  async upsert(attribute: CustomAttribute): Promise<void> {
-    const attributes = await this.accountAPI.customAttributes.list({
-      accountId: this.config.accountId,
-      attributeModel: String(attribute.model) as '0' | '1',
-    });
-    const existing = attributes.find((a) => a.attribute_key === attribute.key);
-
-    if (existing) {
-      await this.accountAPI.customAttributes.update({
-        accountId: this.config.accountId,
-        id: existing.id,
-        data: {
-          attribute_key: attribute.key,
-          attribute_display_name: attribute.name,
-          attribute_display_type: attribute.type,
-          attribute_description: attribute.description,
-        },
-      });
-    } else {
-      await this.accountAPI.customAttributes.create({
-        accountId: this.config.accountId,
-        data: {
-          attribute_key: attribute.key,
-          attribute_display_name: attribute.name,
-          attribute_display_type: attribute.type,
-          attribute_description: attribute.description,
-          attribute_model: attribute.model,
-        },
-      });
-    }
-  }
-}

src/apps/chatwoot/client/CustomAttributesService.ts

@@ -0,0 +1,68 @@
+import ChatwootClient from '@figuro/chatwoot-sdk';
+import { ChatWootAccountAPIConfig } from '@waha/apps/chatwoot/client/interfaces';
+import {
+  CustomAttributeModel,
+  CustomAttributeType,
+} from '@waha/apps/chatwoot/client/types';
+import type { custom_attribute } from '@figuro/chatwoot-sdk/dist/models/custom_attribute';
+
+export interface CustomAttribute {
+  key: string;
+  name: string;
+  type: CustomAttributeType;
+  description: string;
+  model: CustomAttributeModel;
+}
+
+export class CustomAttributesService {
+  constructor(
+    private config: ChatWootAccountAPIConfig,
+    private accountAPI: ChatwootClient,
+  ) {}
+
+  async upsert(attributes: Array<CustomAttribute>): Promise<void> {
+    const current: Record<CustomAttributeModel, Array<custom_attribute>> = {
+      [CustomAttributeModel.CONVERSATION]: [],
+      [CustomAttributeModel.CONTACT]: [],
+    };
+    const models = [
+      CustomAttributeModel.CONVERSATION,
+      CustomAttributeModel.CONTACT,
+    ];
+    for (const model of models) {
+      current[model] = await this.accountAPI.customAttributes.list({
+        accountId: this.config.accountId,
+        attributeModel: String(model) as '0' | '1',
+      });
+    }
+
+    for (const attribute of attributes) {
+      const existing = current[attribute.model].find(
+        (a) => a.attribute_key === attribute.key,
+      );
+      if (existing) {
+        await this.accountAPI.customAttributes.update({
+          accountId: this.config.accountId,
+          id: existing.id,
+          data: {
+            attribute_key: attribute.key,
+            attribute_display_name: attribute.name,
+            attribute_display_type: attribute.type,
+            attribute_description: attribute.description,
+          },
+        });
+      } else {
+        await this.accountAPI.customAttributes.create({
+          accountId: this.config.accountId,
+          data: {
+            attribute_key: attribute.key,
+            attribute_display_name: attribute.name,
+            attribute_display_type: attribute.type,
+            attribute_description: attribute.description,
+            attribute_model: attribute.model,
+          },
+        });
+      }
+    }
+  }
+}

src/apps/chatwoot/client/ids.ts

@@ -15,6 +15,16 @@ export function GetChatID(contact: any): string | null {
   return contact?.custom_attributes?.[AttributeKey.WA_CHAT_ID];
 }
 
+export function GetAllChatIDs(contact: any): Array<string> {
+  const attrs = contact?.custom_attributes || {};
+  const ids = [
+    attrs[AttributeKey.WA_CHAT_ID],
+    attrs[AttributeKey.WA_JID],
+    attrs[AttributeKey.WA_LID],
+  ];
+  return ids.filter(Boolean);
+}
+
 export function FindChatID(contact: any): string | null {
   if (GetJID(contact)) {
     return GetJID(contact);

src/apps/chatwoot/client/types.ts

@@ -51,3 +51,10 @@ export enum CustomAttributeModel {
   CONVERSATION = 0,
   CONTACT = 1,
 }
+
+export enum ConversationStatus {
+  OPEN = 'open',
+  PENDING = 'pending',
+  SNOOZED = 'snoozed',
+  RESOLVED = 'resolved',
+}

src/apps/chatwoot/const.ts

@@ -1,4 +1,4 @@
-import { CustomAttribute } from '@waha/apps/chatwoot/client/CustomAttributesAPI';
+import { CustomAttribute } from '@waha/apps/chatwoot/client/CustomAttributesService';
 
 import { CustomAttributeModel, CustomAttributeType } from './client/types';
 

src/apps/chatwoot/consumers/QueueName.ts

@@ -18,6 +18,8 @@ export enum QueueName {
   //
   INBOX_MESSAGE_CREATED = 'chatwoot.inbox | message_created',
   INBOX_MESSAGE_UPDATED = 'chatwoot.inbox | message_updated',
+  INBOX_CONVERSATION_CREATED = 'chatwoot.inbox | conversation_created',
+  INBOX_CONVERSATION_STATUS_CHANGED = 'chatwoot.inbox | conversation_status_changed',
   //
   // ChatWoot Events - Artificial
   //

src/apps/chatwoot/consumers/inbox/base.ts

@@ -58,13 +58,20 @@ export abstract class ChatWootInboxMessageConsumer extends AppConsumer {
     job: Job,
   ): Promise<any>;
 
+  protected GetConversationID(body) {
+    return body.conversation.id;
+  }
+
   /**
    * Process the job
    * This method is called by the queue processor
    */
   async processJob(job: Job<InboxData, any, EventName>): Promise<any> {
     const body = job.data.body;
-    const key = ChatWootConversationKey(job.data.app, body.conversation.id);
+    const key = ChatWootConversationKey(
+      job.data.app,
+      this.GetConversationID(body),
+    );
     return await this.withMutex(job, key, () =>
       this.ProcessAndReportStatus(job),
     );

src/apps/chatwoot/consumers/inbox/conversation_created.ts

@@ -0,0 +1,57 @@
+import { Processor } from '@nestjs/bullmq';
+import { JOB_CONCURRENCY } from '@waha/apps/app_sdk/constants';
+import { QueueName } from '@waha/apps/chatwoot/consumers/QueueName';
+import { ChatWootConversationKey } from '@waha/apps/chatwoot/consumers/mutex';
+import { ChatWootInboxMessageConsumer } from '@waha/apps/chatwoot/consumers/inbox/base';
+import { InboxData } from '@waha/apps/chatwoot/consumers/types';
+import { Job } from 'bullmq';
+import { GetAllChatIDs } from '@waha/apps/chatwoot/client/ids';
+import { DIContainer } from '@waha/apps/chatwoot/di/DIContainer';
+import { TKey } from '@waha/apps/chatwoot/i18n/templates';
+import { ContactConversationService } from '@waha/apps/chatwoot/client/ContactConversationService';
+import { SessionManager } from '@waha/core/abc/manager.abc';
+import { PinoLogger } from 'nestjs-pino';
+import { RMutexService } from '@waha/modules/rmutex';
+
+@Processor(QueueName.INBOX_CONVERSATION_CREATED, {
+  concurrency: JOB_CONCURRENCY,
+})
+export class ChatWootConversationCreatedConsumer extends ChatWootInboxMessageConsumer {
+  constructor(
+    protected readonly manager: SessionManager,
+    log: PinoLogger,
+    rmutex: RMutexService,
+  ) {
+    super(manager, log, rmutex, 'ChatWootConversationCreatedConsumer');
+  }
+  protected ErrorHeaderKey(): TKey | null {
+    return null;
+  }
+
+  protected GetConversationID(body) {
+    return body.id;
+  }
+
+  protected async Process(
+    container: DIContainer,
+    body: any,
+    job: Job,
+  ): Promise<any> {
+    const handler = new ConversationCreatedHandler(
+      container.ContactConversationService(),
+    );
+    return handler.handle(body);
+  }
+}
+
+class ConversationCreatedHandler {
+  constructor(private service: ContactConversationService) {}
+
+  async handle(body: any) {
+    const ids = GetAllChatIDs(body?.meta?.sender);
+    if (!ids || ids.length === 0) {
+      return;
+    }
+    this.service.ResetMismatchedCache(ids, body.id);
+  }
+}

src/apps/chatwoot/consumers/inbox/conversation_status_changed.ts

@@ -0,0 +1,62 @@
+import { Processor } from '@nestjs/bullmq';
+import { JOB_CONCURRENCY } from '@waha/apps/app_sdk/constants';
+import { QueueName } from '@waha/apps/chatwoot/consumers/QueueName';
+import { ChatWootInboxMessageConsumer } from '@waha/apps/chatwoot/consumers/inbox/base';
+import { Job } from 'bullmq';
+import { DIContainer } from '../../di/DIContainer';
+import { TKey } from '../../i18n/templates';
+import { ContactConversationService } from '@waha/apps/chatwoot/client/ContactConversationService';
+import { AttributeKey } from '@waha/apps/chatwoot/const';
+import { ConversationSelector } from '@waha/apps/chatwoot/services/ConversationSelector';
+import { GetAllChatIDs } from '@waha/apps/chatwoot/client/ids';
+import { SessionManager } from '@waha/core/abc/manager.abc';
+import { PinoLogger } from 'nestjs-pino';
+import { RMutexService } from '@waha/modules/rmutex';
+
+@Processor(QueueName.INBOX_CONVERSATION_STATUS_CHANGED, {
+  concurrency: JOB_CONCURRENCY,
+})
+export class ChatWootConversationStatusChangedConsumer extends ChatWootInboxMessageConsumer {
+  constructor(
+    protected readonly manager: SessionManager,
+    log: PinoLogger,
+    rmutex: RMutexService,
+  ) {
+    super(manager, log, rmutex, 'ChatWootConversationStatusChangedConsumer');
+  }
+
+  protected ErrorHeaderKey(): TKey | null {
+    return null;
+  }
+
+  protected GetConversationID(body) {
+    return body.id;
+  }
+
+  protected async Process(
+    container: DIContainer,
+    body: any,
+    job: Job,
+  ): Promise<any> {
+    const handler = new ConversationStatusChangedHandler(
+      container.ContactConversationService(),
+      container.ConversationSelector(),
+    );
+    return await handler.handle(body);
+  }
+}
+
+class ConversationStatusChangedHandler {
+  constructor(
+    private service: ContactConversationService,
+    private selector: ConversationSelector,
+  ) {}
+
+  async handle(body) {
+    if (!this.selector.hasStatusFilter()) {
+      return;
+    }
+    const ids = GetAllChatIDs(body.meta?.sender);
+    this.service.ResetCache(ids);
+  }
+}

src/apps/chatwoot/consumers/inbox/message_created.ts

@@ -12,6 +12,7 @@ import { EngineHelper } from '@waha/apps/chatwoot/session';
 import { WAHASessionAPI } from '@waha/apps/chatwoot/session/WAHASelf';
 import {
   ChatwootMessage,
+  MessageMapping,
   MessageMappingService,
 } from '@waha/apps/chatwoot/storage';
 import { MarkdownToWhatsApp } from '@waha/apps/chatwoot/text';
@@ -79,7 +80,10 @@ export class MessageHandler {
   async handle(body: any) {
     const chatId = await LookupAndCheckChatId(this.session, body);
     const message = body;
-    if (message.content_type != 'text') {
+    if (
+      message.content_type != 'text' &&
+      message.content_type != 'input_csat'
+    ) {
       this.logger.info(
         `Message content type not supported. Content type: ${message.content_type}`,
       );
@@ -88,29 +92,48 @@ export class MessageHandler {
 
     const content = MarkdownToWhatsApp(message.content);
     const results = [];
-    let part = 1;
+    let part = 0; // Start from 0 and increment before each send/check
     const replyTo = await this.getReplyTo(message).catch((err) => {
-      this.logger.error(`Error getting reply to message ID: ${err}`);
+      this.logger.error(
+        `ChatWoot => WhatsApp: error getting reply to message ID: ${err}`,
+      );
       return undefined;
     });
 
-    // Send text
+    // Send text (Part 1 if present)
     const attachments = message.attachments || [];
-    if (content && attachments.length !== 1) {
-      const textTemplate = this.l.key(TKey.CW_TO_WA_MESSAGE_TEXT);
-      const text = textTemplate.render({
-        content: content,
-        chatwoot: body,
-      });
-      const msg = await this.sendTextMessage(chatId, text, replyTo);
-      results.push(msg);
-      part = await this.saveMapping(message, msg, part);
-      this.logger.info(`Text message sent: ${msg.id}`);
+    const sendText = content && attachments.length !== 1;
+    if (sendText) {
+      part += 1; // Text is the first possible part
+      const exists = await this.getMapping(message, part);
+      if (exists) {
+        this.logger.warn(
+          `Skip part ${part}: mapping exists for Chatwoot message ${message.id}`,
+        );
+      } else {
+        const textTemplate = this.l.key(TKey.CW_TO_WA_MESSAGE_TEXT);
+        const text = textTemplate.render({
+          content: content,
+          chatwoot: body,
+        });
+        const msg = await this.sendTextMessage(chatId, text, replyTo);
+        results.push(msg);
+        await this.saveMapping(message, msg, part);
+        this.logger.info(`Text message sent: ${msg.id}`);
+      }
     }
 
     // Send files
     const captionTemplate = this.l.key(TKey.CW_TO_WA_MESSAGE_MEDIA_CAPTION);
     for (const file of attachments) {
+      part += 1; // Increment before each attachment send/check
+      const exists = await this.getMapping(message, part);
+      if (exists) {
+        this.logger.warn(
+          `Skip part ${part}: mapping exists for Chatwoot message ${message.id}`,
+        );
+        continue;
+      }
       const caption = captionTemplate.render({
         content: content,
         chatwoot: body,
@@ -121,7 +144,7 @@ export class MessageHandler {
         `File message sent: ${msg.id} - ${file.data_url} - ${file.file_type}`,
       );
       results.push(msg);
-      part = await this.saveMapping(message, msg, part);
+      await this.saveMapping(message, msg, part);
     }
     return results;
   }
@@ -130,15 +153,27 @@ export class MessageHandler {
     chatwootMessage: any,
     whatsappMessage: any,
     part: number,
-  ): Promise<number> {
+  ): Promise<void> {
     const chatwoot: Omit<ChatwootMessage, 'id'> = {
       timestamp: new Date(chatwootMessage.created_at),
       conversation_id: chatwootMessage.conversation.id,
       message_id: chatwootMessage.id,
     };
     const whatsapp = EngineHelper.WhatsAppMessageKeys(whatsappMessage);
-    await this.mappingService.map(chatwoot, whatsapp, 1);
-    return part + 1;
+    await this.mappingService.map(chatwoot, whatsapp, part);
+  }
+
+  private async getMapping(
+    message: any,
+    part: number,
+  ): Promise<MessageMapping | null> {
+    return this.mappingService.getMappingByChatwootCombinedKeyAndPart(
+      {
+        conversation_id: message.conversation.id,
+        message_id: message.id,
+      },
+      part,
+    );
   }
 
   async getReplyTo(message): Promise<string | undefined> {

src/apps/chatwoot/consumers/waha/base.ts

@@ -299,7 +299,9 @@ export abstract class MessageBaseHandler<Payload extends WAMessageBase> {
     }
     const replyTo = await this.getReplyToChatWootMessageID(payload).catch(
       (err) => {
-        this.logger.error(`Error getting reply to message ID: ${err}`);
+        this.logger.error(
+          `WhatsApp => ChatWoot - error getting reply to message ID: ${err}`,
+        );
         return undefined;
       },
     );
@@ -327,6 +329,6 @@ export abstract class MessageBaseHandler<Payload extends WAMessageBase> {
       chat_id: payload.from,
       message_id: replyToWhatsAppID,
     });
-    return chatwoot.message_id;
+    return chatwoot?.message_id;
   }
 }

src/apps/chatwoot/consumers/waha/session.status.ts

@@ -20,7 +20,6 @@ import { WAHAWebhookSessionStatus } from '@waha/structures/webhooks.dto';
 import { Job } from 'bullmq';
 import { PinoLogger } from 'nestjs-pino';
 import { TKey } from '@waha/apps/chatwoot/i18n/templates';
-import { sleep } from '@nestjs/terminus/dist/utils';
 import { waitUntil } from '@waha/utils/promiseTimeout';
 
 @Processor(QueueName.WAHA_SESSION_STATUS, { concurrency: JOB_CONCURRENCY })
@@ -103,6 +102,20 @@ export class SessionStatusHandler {
         });
         break;
       case WAHASessionStatus.STOPPED:
+        try {
+          // Check the session is yet in STOPPED status.
+          // In case of server restarts,
+          //  the consumer can process STOPPED after STARTING/WORKING
+          const response = await this.waha.get(data.session);
+          if (response.status != WAHASessionStatus.STOPPED) {
+            return;
+          }
+        } catch (_) {}
+        text = this.l.key(TKey.APP_SESSION_STATUS_ERROR).r();
+        text += '\n\n';
+        text += this.l.key(TKey.APP_HELP_REMINDER).r();
+        text += '\n\n';
+        break;
       case WAHASessionStatus.FAILED:
         text = this.l.key(TKey.APP_SESSION_STATUS_ERROR).r();
         text += '\n\n';

src/apps/chatwoot/contacts/WhatsAppContactInfo.ts

@@ -12,7 +12,10 @@ import {
   isJidNewsletter,
   isJidStatusBroadcast,
   isLidUser,
+  isPnUser,
 } from '@waha/core/utils/jids';
+import { UnknownJIDFormat } from '@waha/apps/chatwoot/errors';
+import { E164Parser } from '@waha/core/utils/PhoneJidNormalizer';
 
 /**
  * Base WhatsApp contact info class
@@ -66,8 +69,7 @@ class JidContactInfo extends ChatContactInfo {
     const contact: any = await this.session.getContact(this.chatId);
     const name =
       contact?.name || contact?.pushName || contact?.pushname || this.chatId;
-    const phoneNumber = this.chatId.split('@')[0];
-    const phoneNumberE164 = '+' + phoneNumber;
+    const phoneNumberE164 = E164Parser.fromJid(this.chatId);
 
     const result: Contact = {
       name: name,
@@ -149,6 +151,7 @@ class GroupContactInfo extends ChatContactInfo {
     const group: any = await this.session?.getGroup(this.chatId);
     if (group) {
       name = group.subject || group.name || group.topic || name;
+      name = group.Name || name;
       const suffix = this.locale
         .key(TKey.WHATSAPP_CONTACT_GROUP_SUFFIX)
         .render();
@@ -266,6 +269,9 @@ export function WhatsAppContactInfo(
     return new BroadcastContactInfo(session, chatId, locale);
   } else if (isLidUser(chatId)) {
     return new LidContactInfo(session, chatId, locale);
+  } else if (isPnUser(chatId)) {
+    return new JidContactInfo(session, chatId, locale);
+  } else {
+    throw new UnknownJIDFormat(chatId);
   }
-  return new JidContactInfo(session, chatId, locale);
 }

src/apps/chatwoot/di/DIContainer.ts

@@ -2,10 +2,10 @@ import ChatwootClient from '@figuro/chatwoot-sdk';
 import * as lodash from 'lodash';
 import { AxiosLogging } from '@waha/apps/app_sdk/AxiosLogging';
 import { ILogger } from '@waha/apps/app_sdk/ILogger';
-import { ContactAPI } from '@waha/apps/chatwoot/client/ContactAPI';
+import { ContactService } from '@waha/apps/chatwoot/client/ContactService';
 import { ContactConversationService } from '@waha/apps/chatwoot/client/ContactConversationService';
-import { ConversationAPI } from '@waha/apps/chatwoot/client/ConversationAPI';
-import { CustomAttributesAPI } from '@waha/apps/chatwoot/client/CustomAttributesAPI';
+import { ConversationService } from '@waha/apps/chatwoot/client/ConversationService';
+import { CustomAttributesService } from '@waha/apps/chatwoot/client/CustomAttributesService';
 import { ChatWootInboxAPI } from '@waha/apps/chatwoot/client/interfaces';
 import {
   ChatWootAppConfig,
@@ -25,21 +25,17 @@ import {
 import { Job } from 'bullmq';
 import { Knex } from 'knex';
 import { i18n } from '@waha/apps/chatwoot/i18n';
+import { CacheSync } from '@waha/utils/Cache';
+import {
+  ConversationSelector,
+  ConversationSort,
+} from '@waha/apps/chatwoot/services/ConversationSelector';
 
 /**
  * Dependency Injection Container for ChatWoot
  * Manages the creation and caching of various clients and repositories
  */
 export class DIContainer {
-  private accountAPI: ChatwootClient;
-  private inboxAPI: ChatWootInboxAPI;
-  private contactAPI: ContactAPI;
-  private conversationAPI: ConversationAPI;
-  private contactConversationService: ContactConversationService;
-  private locale: Locale;
-  private messageMappingService: MessageMappingService;
-  private wahaSelf: WAHASelf;
-
   /**
    * Creates a new DIContainer with the given configuration
    */
@@ -68,122 +64,124 @@ export class DIContainer {
     return this.knex;
   }
 
+  @CacheSync()
   public Locale(): Locale {
-    if (!this.locale) {
-      this.locale = i18n.locale(this.config.locale || DEFAULT_LOCALE);
-      this.locale = this.locale.override(this.ChatWootConfig().templates);
-    }
-    return this.locale;
+    let locale = i18n.locale(this.config.locale || DEFAULT_LOCALE);
+    locale = locale.override(this.ChatWootConfig().templates);
+    return locale;
   }
 
   /**
    * Gets the AccountAPI client
    * @returns ChatwootClient instance
    */
+  @CacheSync()
   public AccountAPI(): ChatwootClient {
-    if (!this.accountAPI) {
-      this.accountAPI = new ChatwootClient({
-        config: {
-          basePath: this.config.url,
-          with_credentials: true,
-          credentials: 'include',
-          token: this.config.accountToken,
-        },
-      });
-    }
-    return this.accountAPI;
+    return new ChatwootClient({
+      config: {
+        basePath: this.config.url,
+        with_credentials: true,
+        credentials: 'include',
+        token: this.config.accountToken,
+      },
+    });
   }
 
   /**
    * Gets the InboxAPI client
    * @returns ChatWootInboxAPI instance
    */
+  @CacheSync()
   public InboxAPI(): ChatWootInboxAPI {
-    if (!this.inboxAPI) {
-      const chatwootClientAPI = new ChatwootClient({
-        config: {
-          basePath: this.config.url,
-          with_credentials: true,
-          credentials: 'include',
-          token: this.config.inboxIdentifier,
-        },
-      });
-      this.inboxAPI = chatwootClientAPI.client as ChatWootInboxAPI;
-    }
-    return this.inboxAPI;
+    const chatwootClientAPI = new ChatwootClient({
+      config: {
+        basePath: this.config.url,
+        with_credentials: true,
+        credentials: 'include',
+        token: this.config.inboxIdentifier,
+      },
+    });
+    return chatwootClientAPI.client as ChatWootInboxAPI;
   }
 
   /**
-   * Gets the ContactAPI
-   * @returns ContactAPI instance
+   * Gets the ContactService
+   * @returns ContactService instance
    */
-  private ContactAPI(): ContactAPI {
-    if (!this.contactAPI) {
-      this.contactAPI = new ContactAPI(
-        this.config,
-        this.AccountAPI(),
-        this.InboxAPI(),
-        this.logger,
-      );
-    }
-    return this.contactAPI;
+  @CacheSync()
+  private ContactService(): ContactService {
+    return new ContactService(
+      this.config,
+      this.AccountAPI(),
+      this.InboxAPI(),
+      this.logger,
+    );
+  }
+
+  @CacheSync()
+  public ConversationSelector() {
+    const config = this.ChatWootConfig();
+    return new ConversationSelector({
+      sort: config.conversations.sort,
+      status: config.conversations.status,
+      inboxId: this.config.inboxId,
+    });
   }
 
   /**
-   * Gets the ConversationAPI
-   * @returns ConversationAPI instance
+   * Gets the ConversationService
+   * @returns ConversationService instance
    */
-  private ConversationAPI(): ConversationAPI {
-    if (!this.conversationAPI) {
-      this.conversationAPI = new ConversationAPI(
-        this.config,
-        this.InboxAPI(),
-        this.logger,
-      );
-    }
-    return this.conversationAPI;
+  @CacheSync()
+  private ConversationService(): ConversationService {
+    return new ConversationService(
+      this.config,
+      this.AccountAPI(),
+      this.InboxAPI(),
+      this.ConversationSelector(),
+      this.logger,
+    );
   }
 
   /**
    * Gets the ContactConversationService
    * @returns ContactConversationService instance
    */
+  @CacheSync()
   public ContactConversationService(): ContactConversationService {
-    if (!this.contactConversationService) {
-      this.contactConversationService = new ContactConversationService(
-        this.config,
-        this.ContactAPI(),
-        this.ConversationAPI(),
-        this.AccountAPI(),
-        this.logger,
-        this.Locale(),
-      );
-    }
-    return this.contactConversationService;
+    return new ContactConversationService(
+      this.config,
+      this.ContactService(),
+      this.ConversationService(),
+      this.AccountAPI(),
+      this.logger,
+      this.Locale(),
+    );
   }
 
+  @CacheSync()
   private ChatwootMessageRepository(): ChatwootMessageRepository {
     return new ChatwootMessageRepository(this.Knex(), this.AppPk());
   }
 
+  @CacheSync()
   private WhatsAppMessageRepository(): WhatsAppMessageRepository {
     return new WhatsAppMessageRepository(this.Knex(), this.AppPk());
   }
 
+  @CacheSync()
   private MessageMappingRepository(): MessageMappingRepository {
     return new MessageMappingRepository(this.Knex(), this.AppPk());
   }
 
+  @CacheSync()
   public MessageMappingService(): MessageMappingService {
-    if (!this.messageMappingService) {
-      this.messageMappingService = new MessageMappingService(
-        this.Knex(),
-        this.WhatsAppMessageRepository(),
-        this.ChatwootMessageRepository(),
-        this.MessageMappingRepository(),
-      );
-    }
-    return this.messageMappingService;
+    return new MessageMappingService(
+      this.Knex(),
+      this.WhatsAppMessageRepository(),
+      this.ChatwootMessageRepository(),
+      this.MessageMappingRepository(),
+    );
   }
 
   public ChatWootErrorReporter(job: Job): ChatWootErrorReporter {
@@ -194,19 +192,20 @@ export class DIContainer {
    * Gets the WAHASelf instance
    * @returns WAHASelf instance
    */
+  @CacheSync()
   public WAHASelf(): WAHASelf {
-    if (!this.wahaSelf) {
-      this.wahaSelf = new WAHASelf();
-      const logging = new AxiosLogging(this.Logger());
-      logging.applyTo(this.wahaSelf.client);
-    }
-    return this.wahaSelf;
+    const self = new WAHASelf();
+    const logging = new AxiosLogging(this.Logger());
+    logging.applyTo(self.client);
+    return self;
   }
 
-  public CustomAttributesAPI() {
-    return new CustomAttributesAPI(this.config, this.AccountAPI());
+  @CacheSync()
+  public CustomAttributesService() {
+    return new CustomAttributesService(this.config, this.AccountAPI());
   }
 
+  @CacheSync()
   public ChatWootConfig(): ChatWootConfig {
     const defaults: ChatWootConfig = {
       templates: {},
@@ -214,6 +213,10 @@ export class DIContainer {
       commands: {
         server: true,
       },
+      conversations: {
+        sort: ConversationSort.created_newest,
+        status: null,
+      },
     };
     return lodash.defaults({}, this.config, defaults);
   }

src/apps/chatwoot/dto/config.dto.ts

@@ -9,6 +9,11 @@ import {
 } from 'class-validator';
 import { Type } from 'class-transformer';
 import { IsDynamicObject } from '@waha/nestjs/validation/IsDynamicObject';
+import {
+  ConversationSelectorConfig,
+  ConversationSort,
+} from '@waha/apps/chatwoot/services/ConversationSelector';
+import { ConversationStatus } from '@waha/apps/chatwoot/client/types';
 
 export const DEFAULT_LOCALE = 'en-US';
 
@@ -23,10 +28,20 @@ export enum LinkPreview {
   HQ = 'HG',
 }
 
+export class ChatWootConversationsConfig {
+  @IsEnum(ConversationSort)
+  sort: ConversationSort;
+
+  @IsOptional()
+  @IsEnum(ConversationStatus, { each: true })
+  status: Array<ConversationStatus> | null;
+}
+
 export interface ChatWootConfig {
   templates: Record<string, string>;
   linkPreview: LinkPreview;
   commands: ChatWootCommandsConfig;
+  conversations: ChatWootConversationsConfig;
 }
 
 export class ChatWootAppConfig implements ChatWootAPIConfig {
@@ -56,7 +71,13 @@ export class ChatWootAppConfig implements ChatWootAPIConfig {
   @IsDynamicObject()
   templates?: Record<string, string>;
 
+  @IsOptional()
   @ValidateNested()
   @Type(() => ChatWootCommandsConfig)
   commands?: ChatWootCommandsConfig;
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => ChatWootConversationsConfig)
+  conversations?: ChatWootConversationsConfig;
 }

src/apps/chatwoot/error/ChatWootErrorReporter.ts

@@ -11,8 +11,10 @@ import { Locale } from '@waha/apps/chatwoot/i18n/locale';
 import { Job } from 'bullmq';
 import { TKey } from '@waha/apps/chatwoot/i18n/templates';
 
+const renderer: ErrorRenderer = new ErrorRenderer();
+
 export class ChatWootErrorReporter {
-  private errorRenderer: ErrorRenderer = new ErrorRenderer();
+  private errorRenderer: ErrorRenderer = renderer;
 
   constructor(
     private logger: ILogger,
@@ -27,8 +29,14 @@ export class ChatWootErrorReporter {
     error: any,
     replyTo?: number,
   ) {
-    const errorText = this.errorRenderer.renderError(error);
+    const errorText = this.errorRenderer.text(error);
     this.logger.error(errorText);
+    try {
+      const data = this.errorRenderer.data(error);
+      this.logger.error(JSON.stringify(data, null, 2));
+    } catch (err) {
+      this.logger.error(`Error occurred while login details for error: ${err}`);
+    }
     const template = this.l.key(TKey.JOB_REPORT_ERROR);
     const nextDelay = NextAttemptDelayInWholeSeconds(this.job);
     const attempts = {
@@ -69,9 +77,6 @@ export class ChatWootErrorReporter {
     type: MessageType,
     replyTo?: number,
   ): Promise<void> {
-    const jobUrl = `http://localhost:3000/jobs/queue/${encodeURIComponent(
-      this.job.queueName,
-    )}/${this.job.id}`;
     const template = this.l.key(TKey.JOB_REPORT_SUCCEEDED);
     const attempts = {
       current: this.job.attemptsMade + 1,
@@ -79,10 +84,7 @@ export class ChatWootErrorReporter {
     };
 
     const content = template.render({
-      details: {
-        text: `${this.job.queueName} => ${this.job.id}`,
-        url: jobUrl,
-      },
+      details: JobLink(this.job),
       attempts: attempts,
     });
 

src/apps/chatwoot/error/ErrorRenderer.ts

@@ -1,45 +1,28 @@
-import { ApiError } from '@figuro/chatwoot-sdk/dist/core/ApiError';
-import { AxiosError } from 'axios';
+import { ApiError as ChatWootAPIError } from '@figuro/chatwoot-sdk/dist/core/ApiError';
+import type { AxiosError } from 'axios';
 
-/**
- * Class responsible for rendering error information based on error type
- */
-export class ErrorRenderer {
+interface IErrorRender<T> {
   /**
-   * Renders error information based on error type
-   * @param error The error to render
-   * @returns Formatted error text
+   * Get an error text to show to the user
    */
-  public renderError(error: any): string {
-    // Handle Axios errors
-    if (error.isAxiosError) {
-      return this.renderAxiosError(error as AxiosError);
-    }
-
-    // Handle Chatwoot SDK ApiError
-    if (error instanceof ApiError) {
-      return this.renderApiError(error);
-    }
-
-    // For all other errors
-    return this.renderGenericError(error);
-  }
+  text(error: T): string;
 
   /**
-   * Renders Axios error information
-   * @param error The Axios error to render
-   * @returns Formatted error text
+   * Structured error data for logging/inspection
    */
-  private renderAxiosError(error: AxiosError): string {
-    let errorText = `Axios Error: ${error.message}`;
+  data(error: T): Record<string, any>;
+}
+
+class AxiosErrorRenderer implements IErrorRender<AxiosError> {
+  text(error: AxiosError): string {
+    let errorText = `API Error: ${error.message}`;
     if (!error.response?.data) {
       return errorText;
     }
 
-    // Add response data if it exists and is JSON
     try {
       const data = error.response.data as any;
-      let json: undefined;
+      let json: any;
       if (Buffer.isBuffer(data)) {
         json = JSON.parse(data.toString());
       } else if (typeof data === 'object') {
@@ -55,16 +38,35 @@ export class ErrorRenderer {
     return errorText;
   }
 
-  /**
-   * Renders Chatwoot SDK ApiError information
-   * @param error The ApiError to render
-   * @returns Formatted error text
-   */
-  private renderApiError(error: ApiError): string {
+  data(error: AxiosError): Record<string, any> {
+    const { config, response, request } = error as any;
+
+    return {
+      class: 'APIError',
+      request: {
+        method: request?.method || config?.method,
+        url: request?.path || config?.url,
+        params: config?.params,
+        body: request?.body || config?.data,
+      },
+      response: {
+        status: response?.status,
+        statusText: response?.statusText,
+        headers: response?.headers,
+        body: response?.data,
+      },
+      message: error.message,
+      code: (error as any)?.code,
+      stack: error.stack,
+    };
+  }
+}
+
+class ChatWootAPIErrorRenderer implements IErrorRender<ChatWootAPIError> {
+  text(error: ChatWootAPIError): string {
     let errorText = `ChatWoot API Error: ${error.message}`;
     errorText += `\nStatus: ${error.status}`;
 
-    // Add body if it exists
     if (error.body) {
       try {
         const body =
@@ -78,12 +80,75 @@ export class ErrorRenderer {
     return errorText;
   }
 
+  data(error: ChatWootAPIError): Record<string, any> {
+    return {
+      class: 'ChatWootAPIError',
+      request: {
+        method: error.request?.method,
+        url: error.request?.url,
+        query: error.request?.query,
+        path: error.request?.path,
+        body: error.request?.body,
+      },
+      response: {
+        status: error.status,
+        statusText: error.statusText,
+        body: error.body,
+      },
+      message: error.message,
+      stack: error.stack,
+    };
+  }
+}
+
+class GenericErrorRenderer implements IErrorRender<any> {
+  text(error: any): string {
+    return error?.toString?.() ?? String(error);
+  }
+
+  data(error: any): Record<string, any> {
+    return {
+      class: error?.name ?? error?.constructor?.name ?? typeof error,
+      message: error?.message ?? String(error),
+      stack: error.stack,
+    };
+  }
+}
+
+/**
+ * Class responsible for rendering error information based on error type
+ */
+export class ErrorRenderer implements IErrorRender<any> {
+  private readonly axiosRenderer = new AxiosErrorRenderer();
+  private readonly chatwootRenderer = new ChatWootAPIErrorRenderer();
+  private readonly genericRenderer = new GenericErrorRenderer();
+
   /**
-   * Renders generic error information
+   * Renders error information based on error type
    * @param error The error to render
    * @returns Formatted error text
    */
-  private renderGenericError(error: any): string {
-    return error.toString();
+  public text(error: any): string {
+    if (error?.isAxiosError) {
+      return this.axiosRenderer.text(error as AxiosError);
+    }
+
+    if (error instanceof ChatWootAPIError) {
+      return this.chatwootRenderer.text(error);
+    }
+
+    return this.genericRenderer.text(error);
+  }
+
+  public data(error: any): Record<string, any> {
+    if (error?.isAxiosError) {
+      return this.axiosRenderer.data(error as AxiosError);
+    }
+
+    if (error instanceof ChatWootAPIError) {
+      return this.chatwootRenderer.data(error);
+    }
+
+    return this.genericRenderer.data(error);
   }
 }

src/apps/chatwoot/errors.ts

@@ -9,3 +9,9 @@ export class PhoneNumberNotFoundInWhatsAppError extends Error {
     super(`Phone number not found in WhatsApp: ${phone}`);
   }
 }
+
+export class UnknownJIDFormat extends Error {
+  constructor(public jid: string) {
+    super(`WhatsApp Chat ID is not recognized: ${jid}`);
+  }
+}

src/apps/chatwoot/services/ChatWootAppService.ts

@@ -119,20 +119,21 @@ export class ChatWootAppService implements IAppService {
     await conversation.incoming(updated);
   }
 
-  async beforeSessionStart(
-    app: App<ChatWootAppConfig>,
-    session: WhatsappSession,
-  ) {
+  beforeSessionStart(app: App<ChatWootAppConfig>, session: WhatsappSession) {
     this.chatWootWAHAQueueService.listenEvents(app.id, session);
-    await this.chatWootScheduleService.schedule(app.id, session.name);
+  }
+
+  afterSessionStart(app: App<ChatWootAppConfig>, session: WhatsappSession) {
+    this.chatWootScheduleService.schedule(app.id, session.name).catch((err) => {
+      this.logger.error('Error scheduling session for ChatWoot');
+      this.logger.error(err, err.stack);
+    });
   }
 
   private async setupCustomAttributes(app: App<ChatWootAppConfig>) {
     const di = new DIContainer(0, app.config, this.logger, null);
-    const api = di.CustomAttributesAPI();
-    for (const attr of CHATWOOT_CUSTOM_ATTRIBUTES) {
-      await api.upsert(attr);
-    }
+    const service = di.CustomAttributesService();
+    await service.upsert(CHATWOOT_CUSTOM_ATTRIBUTES);
   }
 
   private cleanCache(app: App<ChatWootAppConfig>) {

src/apps/chatwoot/services/ChatWootQueueService.ts

@@ -19,6 +19,10 @@ export class ChatWootQueueService {
     private readonly messageUpdatedQueue: Queue,
     @InjectQueue(QueueName.INBOX_MESSAGE_DELETED)
     private readonly messageDeletedQueue: Queue,
+    @InjectQueue(QueueName.INBOX_CONVERSATION_CREATED)
+    private readonly conversationCreatedQueue: Queue,
+    @InjectQueue(QueueName.INBOX_CONVERSATION_STATUS_CHANGED)
+    private readonly conversationStatusChanged: Queue,
     @InjectQueue(QueueName.INBOX_COMMANDS)
     private readonly commandsQueue: Queue,
   ) {}
@@ -41,10 +45,14 @@ export class ChatWootQueueService {
    */
   private getQueueForEvent(event: string): Queue | null {
     switch (event) {
+      case EventName.CONVERSATION_CREATED:
+        return this.conversationCreatedQueue;
       case EventName.MESSAGE_CREATED:
         return this.messageCreatedQueue;
       case EventName.MESSAGE_UPDATED:
         return this.messageUpdatedQueue;
+      case EventName.CONVERSATION_STATUS_CHANGED:
+        return this.conversationStatusChanged;
       case 'message_deleted':
         return this.messageDeletedQueue;
       case 'commands':
@@ -95,9 +103,9 @@ export class ChatWootQueueService {
    */
   async addJobToQueue(event: string, data: InboxData): Promise<any> {
     const queue = this.getQueueForEvent(event);
-    if (queue) {
-      return await this.add(queue, event, data);
+    if (!queue) {
+      return;
     }
-    return { ignored: true, event };
+    await this.add(queue, event, data);
   }
 }

src/apps/chatwoot/services/ConversationSelector.ts

@@ -0,0 +1,72 @@
+import { ConversationStatus } from '@waha/apps/chatwoot/client/types';
+import { contact_conversations } from '@figuro/chatwoot-sdk/dist/models/contact_conversations';
+import * as lodash from 'lodash';
+import type { conversation } from '@figuro/chatwoot-sdk/dist/models/conversation';
+
+export enum ConversationSort {
+  activity_newest = 'activity_newest',
+  created_newest = 'created_newest',
+  created_oldest = 'created_oldest',
+  activity_oldest = 'activity_oldest',
+}
+
+export type ConversationSelectorConfig = {
+  sort: ConversationSort;
+  status?: Array<ConversationStatus>;
+  inboxId: number;
+};
+
+export type ConversationResult = Pick<conversation, 'id' | 'account_id'>;
+
+export class ConversationSelector {
+  constructor(private config: ConversationSelectorConfig) {}
+
+  hasStatusFilter() {
+    return this.config.status;
+  }
+
+  select(conversations: contact_conversations): ConversationResult | null {
+    conversations = this.filter(conversations);
+    conversations = this.sort(conversations);
+    return conversations[0] || null;
+  }
+
+  private filter(conversations: contact_conversations): contact_conversations {
+    // Filter by inbox id
+    conversations = lodash.filter(conversations, {
+      inbox_id: this.config.inboxId,
+    }) as contact_conversations;
+
+    // Filter by status
+    if (this.config.status && this.config.status.length > 0) {
+      conversations = lodash.filter(conversations, (conversation) => {
+        return this.config.status.includes(
+          conversation.status as ConversationStatus,
+        );
+      });
+    }
+    return conversations;
+  }
+
+  private sort(conversations: contact_conversations): contact_conversations {
+    let field = null;
+    let dir = null;
+    switch (this.config.sort) {
+      case ConversationSort.activity_newest:
+        [field, dir] = ['last_activity_at', 'desc'];
+        break;
+      case ConversationSort.created_newest:
+        [field, dir] = ['created_at', 'desc'];
+        break;
+      case ConversationSort.created_oldest:
+        [field, dir] = ['created_at', 'asc'];
+        break;
+      case ConversationSort.activity_oldest:
+        [field, dir] = ['last_activity_at', 'asc'];
+    }
+    if (!field || !dir) {
+      return conversations;
+    }
+    return lodash.orderBy(conversations, [field], [dir]);
+  }
+}

src/apps/chatwoot/storage/MessageMappingRepository.ts

@@ -74,4 +74,17 @@ export class MessageMappingRepository {
       })
       .first();
   }
+
+  async getByChatwootMessageIdAndPart(
+    id: number,
+    part: number,
+  ): Promise<MessageMapping | null> {
+    return this.knex(this.tableName)
+      .where({
+        app_pk: this.appPk,
+        chatwoot_message_id: id,
+        part: part,
+      })
+      .first();
+  }
 }

src/apps/chatwoot/storage/MessageMappingService.ts

@@ -123,4 +123,26 @@ export class MessageMappingService {
     }
     return whatsapp;
   }
+
+  async getMappingByChatwootCombinedKeyAndPart(
+    chatwoot: ChatWootCombinedKey,
+    part: number,
+  ): Promise<MessageMapping | null> {
+    const chatwootMessages =
+      await this.chatwootMessageRepository.getByCombinedKey(chatwoot);
+    if (!chatwootMessages || chatwootMessages.length === 0) {
+      return null;
+    }
+    for (const cw of chatwootMessages) {
+      const mapping =
+        await this.messageMappingRepository.getByChatwootMessageIdAndPart(
+          cw.id,
+          part,
+        );
+      if (mapping) {
+        return mapping;
+      }
+    }
+    return null;
+  }
 }

src/core/abc/manager.abc.ts

@@ -104,10 +104,6 @@ export abstract class SessionManager
     );
   }
 
-  async configureApps(session: WhatsappSession) {
-    await this.appsService.beforeSessionStart(session, this.store);
-  }
-
   //
   // API Methods
   //

src/core/auth/basicAuth.ts

@@ -11,7 +11,7 @@ export function BasicAuthFunction(username, password, exclude: string[] = []) {
     const auth = basicAuth({
       challenge: true,
       users: {
-        [username]: password,
+        [String(username)]: String(password),
       },
     });
     auth(req, res, next);

src/core/engines/gows/session.gows.core.ts

@@ -951,8 +951,8 @@ export class WhatsappSessionGoWSCore extends WhatsappSession {
     const data = response.toObject();
     const info = data.infos[0];
     return {
-      numberExists: info.registered,
-      chatId: toCusFormat(info.jid),
+      numberExists: info?.registered || false,
+      chatId: toCusFormat(info?.jid || null),
     };
   }
 

src/core/engines/noweb/session.noweb.core.ts

@@ -293,7 +293,7 @@ export class WhatsappSessionNoWebCore extends WhatsappSession {
 
   async start() {
     this.status = WAHASessionStatus.STARTING;
-    await this.buildClient().catch((err) => {
+    this.buildClient().catch((err) => {
       this.logger.error('Failed to start the client');
       this.logger.error(err, err.stack);
       this.status = WAHASessionStatus.FAILED;
@@ -641,7 +641,9 @@ export class WhatsappSessionNoWebCore extends WhatsappSession {
         }
         const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey;
         // we need to fetch the poll creation message to get the poll enc key
-        const pollMsg = await this.getMessage(creationMsgKey);
+        const pkey = { ...creationMsgKey };
+        pkey.remoteJid = null; // try to find message creation by id only
+        const pollMsg = await this.getMessage(pkey);
         if (!pollMsg) {
           this.logger.warn(
             { creationMsgKey },
@@ -989,7 +991,7 @@ export class WhatsappSessionNoWebCore extends WhatsappSession {
       force: true,
     };
     const options = await this.getMessageOptions(request);
-    const result = await this.sock.sendMessage(chatId, message, options);
+    const result = await this.sock.sendMessage(chatId, message as any, options);
     return this.toWAMessage(result);
   }
 
@@ -2377,7 +2379,16 @@ export class WhatsappSessionNoWebCore extends WhatsappSession {
     }
 
     const pollCreationMessageKey = key;
-    const pollCreationMessage = await this.getMessage(key);
+    const pkey = { ...key };
+    pkey.remoteJid = null; // try to find message creation by id only
+    const pollCreationMessage = await this.getMessage(pkey);
+    if (!pollCreationMessage) {
+      this.logger.warn(
+        { pollCreationMessageKey },
+        'poll creation message not found, cannot aggregate votes',
+      );
+      return;
+    }
     // Handle updates one by one, so we can get Vote Message for the specific vote
     for (const pollUpdate of pollUpdates) {
       const votes = getAggregateVotesInPollMessage({
@@ -2416,7 +2427,9 @@ export class WhatsappSessionNoWebCore extends WhatsappSession {
       return;
     }
     const pollCreationMessageKey = pollUpdateMessage.pollCreationMessageKey;
-    const pollCreationMessage = await this.getMessage(pollCreationMessageKey);
+    const pkey = { ...pollCreationMessageKey };
+    pkey.remoteJid = null; // try to find message creation by id only
+    const pollCreationMessage = await this.getMessage(pkey);
     if (pollCreationMessage) {
       // We found message, so later the engine will issue a message.update message
       return;

src/core/engines/noweb/store/memory/make-in-memory-store.ts

@@ -414,7 +414,7 @@ export default (config: BaileysInMemoryStoreConfig) => {
     for (const jid in json.messages) {
       const list = assertMessageList(jid);
       for (const msg of json.messages[jid]) {
-        list.upsert(esm.b.proto.WebMessageInfo.create(msg), 'append');
+        list.upsert(esm.b.proto.WebMessageInfo.create(msg) as any, 'append');
       }
     }
   };

src/core/manager.core.ts

@@ -218,11 +218,15 @@ export class SessionManagerCore extends SessionManager implements OnModuleInit {
     webhook.configure(session, webhooks);
 
     // Apps
-    await this.configureApps(session);
+    await this.appsService.beforeSessionStart(session, this.store);
 
     // start session
     await session.start();
     logger.info('Session has been started.');
+
+    // Apps
+    await this.appsService.afterSessionStart(session, this.store);
+
     return {
       name: session.name,
       status: session.status,

src/core/utils/PhoneJidNormalizer.test.ts

@@ -0,0 +1,42 @@
+import { E164Parser } from './PhoneJidNormalizer';
+
+describe('E164Parser.fromJid', () => {
+  it('parses basic JID to +number', () => {
+    expect(E164Parser.fromJid('14155552671@s.whatsapp.net')).toBe(
+      '+14155552671',
+    );
+  });
+
+  it('returns null for empty or missing local part', () => {
+    expect(E164Parser.fromJid('')).toBeNull();
+    expect(E164Parser.fromJid('@s.whatsapp.net')).toBeNull();
+  });
+
+  it('applies Brazil add-9 rule when local has 8 digits (any first digit)', () => {
+    // +55 <DDD:2> <local:8>
+    expect(E164Parser.fromJid('553188888888@s.whatsapp.net')).toBe(
+      '+5531988888888',
+    );
+  });
+
+  it('554999111111 => 5549999111111', () => {
+    expect(E164Parser.fromJid('554999111111@s.whatsapp.net')).toBe(
+      '+5549999111111',
+    );
+  });
+
+  it('adds 9 even when local already starts with 9 (Brazil)', () => {
+    expect(E164Parser.fromJid('553198888888@s.whatsapp.net')).toBe(
+      '+5531998888888',
+    );
+    expect(E164Parser.fromJid('553199999999@s.whatsapp.net')).toBe(
+      '+5531999999999',
+    );
+  });
+
+  it('leaves non-Brazil numbers unchanged', () => {
+    expect(E164Parser.fromJid('447911123456@s.whatsapp.net')).toBe(
+      '+447911123456',
+    );
+  });
+});

src/core/utils/PhoneJidNormalizer.ts

@@ -0,0 +1,64 @@
+type RewriteRule = {
+  name: string;
+  re: RegExp;
+  replace: string;
+};
+
+/**
+ * Convert JID to Phone Number if possible
+ * Applies some formatting rules
+ */
+export class PhoneJidNormalizer {
+  constructor(private rules: RewriteRule[] = []) {}
+
+  /**
+   * jid like "553188888888@s.whatsapp.net" → "+553188888888"
+   */
+  private parseFromJid(jid: string): string | null {
+    if (!jid) {
+      return null;
+    }
+    const local = jid.split('@', 1)[0] ?? '';
+    if (!local) {
+      return null;
+    }
+    return `+${local}`;
+  }
+
+  /**
+   * Apply rewrite rules
+   */
+  private rewrite(number: string): string {
+    for (const rule of this.rules) {
+      if (rule.re.test(number)) {
+        number = number.replace(rule.re, rule.replace);
+        return number;
+      }
+    }
+    return number;
+  }
+
+  /**
+   * Converts a JID (Jabber ID) into an E.164 formatted phone number string.
+   * Applies rules if any
+   */
+  fromJid(jid: string): string | null {
+    let number = this.parseFromJid(jid);
+    if (!number) {
+      return null;
+    }
+    number = this.rewrite(number);
+    return number;
+  }
+}
+
+const RULES = [
+  // Brazil - ensure mobile numbers have 9 digits after DDD
+  {
+    name: 'br-add-9-after-ddd',
+    re: /^\+55(\d{2})(\d{8})$/,
+    replace: '+55$19$2',
+  },
+];
+
+export const E164Parser = new PhoneJidNormalizer(RULES);

src/utils/Cache.ts

@@ -21,3 +21,34 @@ export function CacheAsync() {
     };
   };
 }
+
+export function CacheSync() {
+  return function (
+    _target: any,
+    propertyKey: string,
+    descriptor: PropertyDescriptor,
+  ) {
+    const original = descriptor.value as (...args: any[]) => any;
+    if (typeof original !== 'function') {
+      throw new Error('@CacheSync can only decorate methods');
+    }
+
+    const symbol = Symbol(`__cache_${propertyKey}`);
+
+    descriptor.value = function (...args: any[]) {
+      if (Object.prototype.hasOwnProperty.call(this, symbol)) {
+        return (this as any)[symbol];
+      }
+      const result = original.apply(this, args);
+      Object.defineProperty(this, symbol, {
+        value: result,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+      });
+      return result;
+    };
+
+    return descriptor;
+  };
+}

src/version.ts

@@ -30,7 +30,7 @@ export function getWAHAVersion(): WAHAVersion {
 }
 
 export const VERSION: WAHAEnvironment = {
-  version: '2025.9.5',
+  version: '2025.9.8',
   engine: getEngineName(),
   tier: getWAHAVersion(),
   browser:

waha.config.json

@@ -2,11 +2,11 @@
   "waha": {
     "gows": {
       "repo": "devlikeapro/gows",
-      "ref": "v1.0.15"
+      "ref": "v1.0.16"
     },
     "dashboard": {
       "repo": "devlikeapro/dashboard",
-      "ref": "f3e0934f496f7557bdda67f38efa197df44ceabe"
+      "ref": "0d3523523e9d0e9d8aece8dec8a38b5fee23caad"
     }
   }
 }

yarn.lock

@@ -5,17 +5,17 @@ __metadata:
   version: 6
   cacheKey: 8
 
-"@adiwajshing/baileys@github:devlikeapro/Baileys#fork-master-2025-09-21":
-  version: 7.0.0-rc.3
-  resolution: "@adiwajshing/baileys@https://github.com/devlikeapro/Baileys.git#commit=7198ccbb5f571dd3f7420f112379996bc41fa659"
+"@adiwajshing/baileys@github:devlikeapro/Baileys#fork-master-2025-10-03":
+  version: 7.0.0-rc.5
+  resolution: "@adiwajshing/baileys@https://github.com/devlikeapro/Baileys.git#commit=595c16de1b2f14731a81b1fe7baee6fd1f768552"
   dependencies:
     "@cacheable/node-cache": ^1.4.0
     "@hapi/boom": ^9.1.3
     async-mutex: ^0.5.0
-    axios: ^1.6.0
     libsignal: "git+https://github.com/whiskeysockets/libsignal-node"
     lru-cache: ^11.1.0
     music-metadata: ^11.7.0
+    p-queue: ^9.0.0
     pino: ^9.6
     protobufjs: ^7.2.4
     ws: ^8.13.0
@@ -31,7 +31,7 @@ __metadata:
       optional: true
     link-preview-js:
       optional: true
-  checksum: bb8f5d9dac5faca5034d829507f70f4d3b71d821bec4ebeab645d774811b12962c4e0a5625d2cb6040e32cc653879acc8911188e9a558b03bd6d696eaefc68ae
+  checksum: 74aa8dd2ecaa9ef57ef4a5c8482a83098623a03d7504c5b4bfee255437a63a93da9fedc40acca24c954f7f28369cec036b7faa9cc5bbd3463586908c95383836
   languageName: node
   linkType: hard
 
@@ -6500,6 +6500,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"eventemitter3@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "eventemitter3@npm:5.0.1"
+  checksum: 543d6c858ab699303c3c32e0f0f47fc64d360bf73c3daf0ac0b5079710e340d6fe9f15487f94e66c629f5f82cd1a8678d692f3dbb6f6fcd1190e1b97fcad36f8
+  languageName: node
+  linkType: hard
+
 "events@npm:^3.2.0, events@npm:^3.3.0":
   version: 3.3.0
   resolution: "events@npm:3.3.0"
@@ -9807,6 +9814,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"p-queue@npm:^9.0.0":
+  version: 9.0.0
+  resolution: "p-queue@npm:9.0.0"
+  dependencies:
+    eventemitter3: ^5.0.1
+    p-timeout: ^7.0.0
+  checksum: d9d9567f939cbece7799f5c18be97e2093f38bb8542f3525d75906c0d96ddbe2273043b4e0ffb1878707dffd5facde8cc628913259bb1fb17263f843b995f0cb
+  languageName: node
+  linkType: hard
+
+"p-timeout@npm:^7.0.0":
+  version: 7.0.0
+  resolution: "p-timeout@npm:7.0.0"
+  checksum: dbaeaae7186f265ddf11bb0315e8b410feced475f5ae2f5e6018c09dd321398272591c8b97261c4ad9ceecf62449f0efbbf66057c8ad9240482e123897082b41
+  languageName: node
+  linkType: hard
+
 "p-try@npm:^2.0.0":
   version: 2.2.0
   resolution: "p-try@npm:2.2.0"
@@ -12470,7 +12494,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "waha@workspace:."
   dependencies:
-    "@adiwajshing/baileys": "github:devlikeapro/Baileys#fork-master-2025-09-21"
+    "@adiwajshing/baileys": "github:devlikeapro/Baileys#fork-master-2025-10-03"
     "@adiwajshing/keyed-db": ^0.2.4
     "@aws-sdk/client-s3": ^3.633.0
     "@aws-sdk/s3-request-presigner": ^3.633.0
@@ -12672,7 +12696,7 @@ __metadata:
 
 "whatsapp-web.js@github:devlikeapro/whatsapp-web.js#fork-main-2025-09-10":
   version: 1.34.1
-  resolution: "whatsapp-web.js@https://github.com/devlikeapro/whatsapp-web.js.git#commit=67ed942bfa5b9bc4464d004d1691b7437ead989f"
+  resolution: "whatsapp-web.js@https://github.com/devlikeapro/whatsapp-web.js.git#commit=b11112cdcfecdfd5b13b504fda75fc0558b22e1d"
   dependencies:
     "@pedroslopez/moduleraid": ^5.0.2
     archiver: ^5.3.1
@@ -12690,7 +12714,7 @@ __metadata:
       optional: true
     unzipper:
       optional: true
-  checksum: a0852af6f93d776438db5cf8138933b241cd44a6d4a93c245e74cd587d005c08a007d73f9925d1bca8f89991a8567a3dde603d094312b82e620a7f8133c2183e
+  checksum: f1f17eace3c0d82c1dfe674ea884db3be25b566d8322fd34167827aeb1044df11c1a3dcfc2605e4a5b613bd98e21cfd7d4dddd9a2926c3a0ec0fa57ec9501597
   languageName: node
   linkType: hard