@leg3ndy/otto-bridge 0.8.1 → 0.8.2

package/dist/http.js

@@ -29,6 +29,12 @@ async function requestJson(apiBaseUrl, pathname, init) {
 export async function getJson(apiBaseUrl, pathname) {
     return await requestJson(apiBaseUrl, pathname);
 }
+export async function getDeviceJson(apiBaseUrl, deviceToken, pathname) {
+    return await requestJson(apiBaseUrl, pathname, {
+        method: "GET",
+        headers: buildDeviceAuthHeaders(deviceToken),
+    });
+}
 export async function postJson(apiBaseUrl, pathname, body) {
     return await requestJson(apiBaseUrl, pathname, {
         method: "POST",

package/dist/local_automations.js

@@ -0,0 +1,559 @@
+import { createHash } from "node:crypto";
+import { loadManagedBridgeExtensionState } from "./extensions.js";
+import { getDeviceJson, postDeviceJson } from "./http.js";
+import { WhatsAppBackgroundBrowser } from "./whatsapp_background.js";
+const AUTOMATION_SYNC_INTERVAL_MS = 30_000;
+const AUTOMATION_TICK_INTERVAL_MS = 5_000;
+const DEFAULT_WHATSAPP_MESSAGE_LIMIT = 24;
+const DEFAULT_WHATSAPP_INBOX_SCAN_LIMIT = 12;
+const MAX_WHATSAPP_INBOX_CONVERSATIONS_PER_TICK = 5;
+const DEFAULT_LOCAL_AUTOMATION_TIMEZONE = "America/Sao_Paulo";
+const WEEKDAY_TO_INDEX = {
+    sun: 0,
+    mon: 1,
+    tue: 2,
+    wed: 3,
+    thu: 4,
+    fri: 5,
+    sat: 6,
+};
+const zonedFormatterCache = new Map();
+function clipText(value, maxLength) {
+    const text = String(value || "").trim();
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `${text.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+function normalizeStatus(value) {
+    return String(value || "").trim().toLowerCase();
+}
+function normalizeChannel(value) {
+    return String(value || "").trim().toLowerCase();
+}
+function normalizeWeekday(value) {
+    return String(value || "").trim().toLowerCase().slice(0, 3);
+}
+function isActiveAutomation(automation) {
+    return normalizeStatus(automation.status) === "active";
+}
+function sanitizeMessages(value, limit = DEFAULT_WHATSAPP_MESSAGE_LIMIT) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const messages = [];
+    const startIndex = Math.max(0, value.length - Math.max(1, Math.min(limit, 40)));
+    for (const item of value.slice(startIndex)) {
+        if (!item || typeof item !== "object") {
+            continue;
+        }
+        const rawAuthor = "author" in item ? item.author : "Contato";
+        const rawText = "text" in item ? item.text : "";
+        const text = clipText(rawText, 500);
+        if (!text) {
+            continue;
+        }
+        messages.push({
+            author: clipText(rawAuthor || "Contato", 80) || "Contato",
+            text,
+        });
+    }
+    return messages;
+}
+function computeDeltaHash(contact, messages) {
+    const payload = JSON.stringify({
+        contact: contact.trim(),
+        messages,
+    }, null, 0);
+    return createHash("sha256").update(payload).digest("hex");
+}
+function normalizeThreadKey(value) {
+    const normalized = String(value || "")
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .trim();
+    const slug = normalized.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+    return slug || "whatsapp-thread";
+}
+function parseIsoTimestamp(value) {
+    const text = String(value || "").trim();
+    if (!text) {
+        return null;
+    }
+    const timestamp = Date.parse(text);
+    return Number.isFinite(timestamp) ? timestamp : null;
+}
+function getFormatter(timeZone) {
+    const cacheKey = timeZone || DEFAULT_LOCAL_AUTOMATION_TIMEZONE;
+    const existing = zonedFormatterCache.get(cacheKey);
+    if (existing) {
+        return existing;
+    }
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: cacheKey,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        weekday: "short",
+        hour12: false,
+    });
+    zonedFormatterCache.set(cacheKey, formatter);
+    return formatter;
+}
+function getZonedDateParts(epochMs, timeZone) {
+    const formatter = getFormatter(timeZone);
+    const parts = formatter.formatToParts(new Date(epochMs));
+    const values = {};
+    for (const part of parts) {
+        if (part.type !== "literal") {
+            values[part.type] = part.value;
+        }
+    }
+    const weekdayToken = normalizeWeekday(values.weekday);
+    return {
+        year: Number(values.year || "0"),
+        month: Number(values.month || "0"),
+        day: Number(values.day || "0"),
+        hour: Number(values.hour || "0"),
+        minute: Number(values.minute || "0"),
+        second: Number(values.second || "0"),
+        weekday: WEEKDAY_TO_INDEX[weekdayToken] ?? 0,
+    };
+}
+function getTimeZoneOffsetMs(epochMs, timeZone) {
+    const zoned = getZonedDateParts(epochMs, timeZone);
+    const asUtc = Date.UTC(zoned.year, zoned.month - 1, zoned.day, zoned.hour, zoned.minute, zoned.second);
+    return asUtc - epochMs;
+}
+function zonedDateTimeToUtcMs(date, hour, minute, timeZone) {
+    const targetUtc = Date.UTC(date.year, date.month - 1, date.day, hour, minute, 0);
+    let current = targetUtc;
+    for (let iteration = 0; iteration < 3; iteration += 1) {
+        const offset = getTimeZoneOffsetMs(current, timeZone);
+        const adjusted = targetUtc - offset;
+        if (Math.abs(adjusted - current) < 1000) {
+            return adjusted;
+        }
+        current = adjusted;
+    }
+    return current;
+}
+function addCalendarDays(date, days) {
+    const value = new Date(Date.UTC(date.year, date.month - 1, date.day, 12, 0, 0));
+    value.setUTCDate(value.getUTCDate() + days);
+    return {
+        year: value.getUTCFullYear(),
+        month: value.getUTCMonth() + 1,
+        day: value.getUTCDate(),
+    };
+}
+function parseScheduleTime(value) {
+    const text = String(value || "").trim();
+    const match = text.match(/^(\d{1,2}):(\d{2})$/);
+    if (!match) {
+        return null;
+    }
+    const hour = Number(match[1]);
+    const minute = Number(match[2]);
+    if (!Number.isFinite(hour) || !Number.isFinite(minute) || hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+        return null;
+    }
+    return { hour, minute };
+}
+function resolveTimeZone(scheduleConfig) {
+    return String(scheduleConfig?.timezone || DEFAULT_LOCAL_AUTOMATION_TIMEZONE).trim() || DEFAULT_LOCAL_AUTOMATION_TIMEZONE;
+}
+function computeNextDueAt(automation, nowMs) {
+    const scheduleConfig = automation.schedule_config || {};
+    const scheduleType = String(scheduleConfig.type || "").trim().toLowerCase();
+    if (scheduleType === "interval") {
+        const minutes = Math.max(1, Number(scheduleConfig.minutes || 0));
+        return nowMs + minutes * 60_000;
+    }
+    const time = parseScheduleTime(scheduleConfig.time);
+    if (!time) {
+        return nowMs + 5 * 60_000;
+    }
+    const timeZone = resolveTimeZone(scheduleConfig);
+    const localNow = getZonedDateParts(nowMs, timeZone);
+    if (scheduleType === "daily") {
+        let candidate = zonedDateTimeToUtcMs(localNow, time.hour, time.minute, timeZone);
+        if (candidate <= nowMs) {
+            candidate = zonedDateTimeToUtcMs(addCalendarDays(localNow, 1), time.hour, time.minute, timeZone);
+        }
+        return candidate;
+    }
+    if (scheduleType === "weekly") {
+        const allowedDays = new Set(Array.isArray(scheduleConfig.days)
+            ? scheduleConfig.days
+                .map((item) => WEEKDAY_TO_INDEX[normalizeWeekday(item)])
+                .filter((item) => item !== undefined)
+            : []);
+        if (!allowedDays.size) {
+            return nowMs + 24 * 60 * 60_000;
+        }
+        for (let offset = 0; offset < 8; offset += 1) {
+            const candidateDate = addCalendarDays(localNow, offset);
+            const candidateWeekday = new Date(Date.UTC(candidateDate.year, candidateDate.month - 1, candidateDate.day, 12, 0, 0)).getUTCDay();
+            if (!allowedDays.has(candidateWeekday)) {
+                continue;
+            }
+            const candidate = zonedDateTimeToUtcMs(candidateDate, time.hour, time.minute, timeZone);
+            if (candidate > nowMs) {
+                return candidate;
+            }
+        }
+    }
+    return nowMs + 24 * 60 * 60_000;
+}
+function computeInitialDueAt(automation, nowMs) {
+    const nextRunAt = parseIsoTimestamp(automation.next_run_at);
+    if (nextRunAt !== null) {
+        return nextRunAt;
+    }
+    return nowMs;
+}
+function isSupportedWhatsAppContactAutomation(automation) {
+    if (normalizeChannel(automation.channel) !== "whatsapp") {
+        return false;
+    }
+    const bridgeConfig = automation.bridge_config || {};
+    return String(bridgeConfig.monitor_scope || "contact").trim().toLowerCase() === "contact"
+        && Boolean(String(bridgeConfig.contact || "").trim());
+}
+function isSupportedWhatsAppInboxAutomation(automation) {
+    if (normalizeChannel(automation.channel) !== "whatsapp") {
+        return false;
+    }
+    const bridgeConfig = automation.bridge_config || {};
+    return String(bridgeConfig.monitor_scope || "").trim().toLowerCase() === "inbox";
+}
+export class LocalAutomationRuntime {
+    config;
+    automations = new Map();
+    states = new Map();
+    syncTimer = null;
+    tickTimer = null;
+    syncInFlight = false;
+    tickInFlight = false;
+    started = false;
+    stopped = false;
+    whatsappBrowser = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.stopped = false;
+        await this.syncAutomations().catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            console.warn(`[otto-bridge] local automations sync failed: ${detail}`);
+        });
+        await this.tick().catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            console.warn(`[otto-bridge] local automations tick failed: ${detail}`);
+        });
+        this.syncTimer = setInterval(() => {
+            void this.syncAutomations();
+        }, AUTOMATION_SYNC_INTERVAL_MS);
+        this.tickTimer = setInterval(() => {
+            void this.tick();
+        }, AUTOMATION_TICK_INTERVAL_MS);
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.syncTimer) {
+            clearInterval(this.syncTimer);
+            this.syncTimer = null;
+        }
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+        const browser = this.whatsappBrowser;
+        this.whatsappBrowser = null;
+        if (browser) {
+            await browser.close().catch(() => undefined);
+        }
+    }
+    async syncAutomations() {
+        if (this.syncInFlight || this.stopped) {
+            return;
+        }
+        this.syncInFlight = true;
+        try {
+            const response = await getDeviceJson(this.config.apiBaseUrl, this.config.deviceToken, "/v1/devices/automations/local");
+            const nowMs = Date.now();
+            const activeIds = new Set();
+            const automations = Array.isArray(response.automations) ? response.automations : [];
+            for (const automation of automations) {
+                const automationId = String(automation.id || "").trim();
+                if (!automationId) {
+                    continue;
+                }
+                activeIds.add(automationId);
+                this.automations.set(automationId, automation);
+                const current = this.states.get(automationId);
+                const serverDeltaHash = automation.local_state?.last_known_delta_hash
+                    ? String(automation.local_state.last_known_delta_hash).trim()
+                    : null;
+                const threadDeltaHashes = {
+                    ...(current?.threadDeltaHashes || {}),
+                    ...(automation.local_state?.thread_delta_hashes && typeof automation.local_state.thread_delta_hashes === "object"
+                        ? automation.local_state.thread_delta_hashes
+                        : {}),
+                };
+                const configuredContact = String(automation.bridge_config?.contact || "").trim();
+                if (configuredContact && serverDeltaHash) {
+                    threadDeltaHashes[normalizeThreadKey(configuredContact)] = threadDeltaHashes[normalizeThreadKey(configuredContact)] || serverDeltaHash;
+                }
+                this.states.set(automationId, {
+                    nextDueAtMs: current?.nextDueAtMs ?? computeInitialDueAt(automation, nowMs),
+                    running: current?.running ?? false,
+                    lastKnownDeltaHash: current?.lastKnownDeltaHash ?? serverDeltaHash,
+                    threadDeltaHashes,
+                });
+            }
+            for (const automationId of Array.from(this.automations.keys())) {
+                if (!activeIds.has(automationId)) {
+                    this.automations.delete(automationId);
+                    this.states.delete(automationId);
+                }
+            }
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            console.warn(`[otto-bridge] local automations sync failed: ${detail}`);
+        }
+        finally {
+            this.syncInFlight = false;
+        }
+    }
+    async tick() {
+        if (this.tickInFlight || this.stopped) {
+            return;
+        }
+        this.tickInFlight = true;
+        try {
+            const nowMs = Date.now();
+            for (const automation of this.automations.values()) {
+                const automationId = String(automation.id || "").trim();
+                if (!automationId) {
+                    continue;
+                }
+                const state = this.states.get(automationId);
+                if (!state || state.running || !isActiveAutomation(automation) || nowMs < state.nextDueAtMs) {
+                    continue;
+                }
+                state.running = true;
+                try {
+                    if (isSupportedWhatsAppContactAutomation(automation)) {
+                        await this.handleWhatsAppContactAutomation(automation, state);
+                    }
+                    else if (isSupportedWhatsAppInboxAutomation(automation)) {
+                        await this.handleWhatsAppInboxAutomation(automation, state);
+                    }
+                }
+                catch (error) {
+                    const detail = error instanceof Error ? error.message : String(error);
+                    console.warn(`[otto-bridge] local automation failed id=${automationId}: ${detail}`);
+                }
+                finally {
+                    state.running = false;
+                    state.nextDueAtMs = computeNextDueAt(automation, Date.now());
+                    this.states.set(automationId, state);
+                }
+            }
+        }
+        finally {
+            this.tickInFlight = false;
+        }
+    }
+    async ensureWhatsAppBrowser() {
+        if (!this.whatsappBrowser) {
+            this.whatsappBrowser = new WhatsAppBackgroundBrowser({ background: true });
+        }
+        return this.whatsappBrowser;
+    }
+    async handleWhatsAppContactAutomation(automation, state) {
+        const extensionState = await loadManagedBridgeExtensionState("whatsappweb");
+        if (!extensionState || extensionState.status !== "connected") {
+            return;
+        }
+        const bridgeConfig = automation.bridge_config || {};
+        const contact = String(bridgeConfig.contact || "").trim();
+        if (!contact) {
+            return;
+        }
+        const browser = await this.ensureWhatsAppBrowser();
+        await browser.ensureReady();
+        const selected = await browser.selectConversation(contact);
+        if (!selected) {
+            console.warn(`[otto-bridge] local whatsapp automation could not find contact="${contact}"`);
+            return;
+        }
+        await this.processWhatsAppConversation(automation, state, browser, contact, { alreadySelected: true });
+    }
+    async handleWhatsAppInboxAutomation(automation, state) {
+        const extensionState = await loadManagedBridgeExtensionState("whatsappweb");
+        if (!extensionState || extensionState.status !== "connected") {
+            return;
+        }
+        const browser = await this.ensureWhatsAppBrowser();
+        await browser.ensureReady();
+        const conversations = await browser.scanInboxConversations(DEFAULT_WHATSAPP_INBOX_SCAN_LIMIT, {
+            unreadOnly: true,
+        });
+        if (!Array.isArray(conversations) || conversations.length === 0) {
+            return;
+        }
+        const selectedConversations = conversations
+            .filter((item) => item && String(item.contact || "").trim())
+            .slice(0, MAX_WHATSAPP_INBOX_CONVERSATIONS_PER_TICK);
+        for (const conversation of selectedConversations) {
+            const contact = String(conversation.contact || "").trim();
+            if (!contact) {
+                continue;
+            }
+            try {
+                const selected = await browser.selectConversation(contact);
+                if (!selected) {
+                    console.warn(`[otto-bridge] local whatsapp inbox automation could not find contact="${contact}"`);
+                    continue;
+                }
+                await this.processWhatsAppConversation(automation, state, browser, contact, {
+                    alreadySelected: true,
+                    inboxConversation: conversation,
+                });
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                console.warn(`[otto-bridge] local whatsapp inbox conversation failed contact="${contact}": ${detail}`);
+            }
+        }
+    }
+    isPrimaryContactForAutomation(automation, contact) {
+        if (!isSupportedWhatsAppContactAutomation(automation)) {
+            return false;
+        }
+        const configuredContact = String(automation.bridge_config?.contact || "").trim();
+        if (!configuredContact) {
+            return true;
+        }
+        return normalizeThreadKey(configuredContact) === normalizeThreadKey(contact);
+    }
+    getKnownDeltaHash(automation, state, contact) {
+        const threadHash = state.threadDeltaHashes[normalizeThreadKey(contact)];
+        if (threadHash) {
+            return threadHash;
+        }
+        if (this.isPrimaryContactForAutomation(automation, contact) && state.lastKnownDeltaHash) {
+            return state.lastKnownDeltaHash;
+        }
+        return null;
+    }
+    rememberDeltaHash(automation, state, contact, deltaHash) {
+        const normalizedHash = String(deltaHash || "").trim();
+        if (!normalizedHash) {
+            return;
+        }
+        state.threadDeltaHashes[normalizeThreadKey(contact)] = normalizedHash;
+        if (this.isPrimaryContactForAutomation(automation, contact)) {
+            state.lastKnownDeltaHash = normalizedHash;
+        }
+    }
+    shouldRememberDispositionDelta(disposition) {
+        return disposition === "session_created"
+            || disposition === "skipped_no_delta"
+            || disposition === "skipped_rate_limited"
+            || disposition === "skipped_plan_disabled";
+    }
+    async processWhatsAppConversation(automation, state, browser, contact, options) {
+        if (!options?.alreadySelected) {
+            const selected = await browser.selectConversation(contact);
+            if (!selected) {
+                console.warn(`[otto-bridge] local whatsapp automation could not find contact="${contact}"`);
+                return;
+            }
+        }
+        await browser.waitForTimeout(500);
+        const chat = await browser.readVisibleConversation(DEFAULT_WHATSAPP_MESSAGE_LIMIT);
+        const messages = sanitizeMessages(chat.messages, DEFAULT_WHATSAPP_MESSAGE_LIMIT);
+        if (!messages.length) {
+            return;
+        }
+        const deltaHash = computeDeltaHash(contact, messages);
+        const previousDeltaHash = this.getKnownDeltaHash(automation, state, contact);
+        if (previousDeltaHash && previousDeltaHash === deltaHash) {
+            return;
+        }
+        const eventResponse = await postDeviceJson(this.config.apiBaseUrl, this.config.deviceToken, "/v1/devices/automations/local/events", {
+            automation_id: automation.id,
+            event_type: "whatsapp_snapshot",
+            contact,
+            delta_hash: deltaHash,
+            summary: chat.summary || options?.inboxConversation?.preview || undefined,
+            messages,
+        });
+        const disposition = String(eventResponse.disposition || "").trim().toLowerCase();
+        if (this.shouldRememberDispositionDelta(disposition)) {
+            this.rememberDeltaHash(automation, state, contact, String(eventResponse.last_delta_hash || deltaHash || "").trim() || deltaHash);
+            return;
+        }
+        if (disposition !== "requires_auto_reply_send") {
+            return;
+        }
+        const runId = String(eventResponse.run?.id || "").trim();
+        const replyText = clipText(eventResponse.reply_action?.text || "", 2000);
+        if (!runId || !replyText) {
+            this.rememberDeltaHash(automation, state, contact, deltaHash);
+            return;
+        }
+        let sent = false;
+        let errorMessage = "";
+        let completionMessages = messages;
+        try {
+            await browser.sendMessage(replyText);
+            await browser.waitForTimeout(900);
+            const verification = await browser.verifyLastMessage(replyText, messages);
+            const afterChat = await browser.readVisibleConversation(Math.max(DEFAULT_WHATSAPP_MESSAGE_LIMIT, messages.length + 4));
+            completionMessages = sanitizeMessages(afterChat.messages, Math.max(DEFAULT_WHATSAPP_MESSAGE_LIMIT, messages.length + 4));
+            sent = verification.ok;
+            if (!sent) {
+                errorMessage = verification.reason || "Nao consegui confirmar o envio da resposta automatica.";
+            }
+        }
+        catch (error) {
+            errorMessage = error instanceof Error ? error.message : String(error);
+            const afterChat = await browser.readVisibleConversation(Math.max(DEFAULT_WHATSAPP_MESSAGE_LIMIT, messages.length + 4))
+                .catch(() => ({ messages, summary: chat.summary }));
+            completionMessages = sanitizeMessages(afterChat.messages, Math.max(DEFAULT_WHATSAPP_MESSAGE_LIMIT, messages.length + 4));
+        }
+        const completionDeltaHash = computeDeltaHash(contact, completionMessages);
+        try {
+            const completionResponse = await postDeviceJson(this.config.apiBaseUrl, this.config.deviceToken, `/v1/devices/automations/local/runs/${encodeURIComponent(runId)}/complete`, {
+                automation_id: automation.id,
+                contact,
+                sent,
+                delta_hash: completionDeltaHash,
+                summary: chat.summary || undefined,
+                sent_text: replyText,
+                error_message: errorMessage || undefined,
+                messages: completionMessages,
+            });
+            const persistedDeltaHash = String(completionResponse.last_delta_hash || "").trim();
+            this.rememberDeltaHash(automation, state, contact, persistedDeltaHash || (sent ? completionDeltaHash : deltaHash));
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            console.warn(`[otto-bridge] local whatsapp completion failed id=${automation.id}: ${detail}`);
+            this.rememberDeltaHash(automation, state, contact, sent ? completionDeltaHash : deltaHash);
+        }
+    }
+}

package/dist/macos_whatsapp_helper.js

@@ -629,6 +629,117 @@ export class MacOSWhatsAppHelperRuntime {
                 : "(sem mensagens visiveis na conversa)",
         };
     }
+    async scanInboxConversations(limit, options) {
+        await this.ensureReady();
+        const unreadOnly = options?.unreadOnly === true;
+        const result = await this.evaluate(`
+(() => {
+  const maxItems = ${Math.max(1, Number(limit || 10))};
+  const unreadOnly = ${JSON.stringify(unreadOnly)};
+  const normalize = (value) => String(value || "").normalize("NFD").replace(/[\\u0300-\\u036f]/g, "").toLowerCase().trim();
+
+  function isVisible(element) {
+    if (!(element instanceof HTMLElement)) return false;
+    const rect = element.getBoundingClientRect();
+    if (rect.width < 6 || rect.height < 6) return false;
+    const style = window.getComputedStyle(element);
+    if (style.visibility === "hidden" || style.display === "none" || Number(style.opacity || "1") === 0) return false;
+    return rect.bottom >= 0 && rect.right >= 0 && rect.top <= window.innerHeight && rect.left <= window.innerWidth;
+  }
+
+  const uniqueContainers = new Set();
+  const containers = Array.from(document.querySelectorAll(
+    '#pane-side [role="listitem"], #pane-side [role="gridcell"], #pane-side [data-testid="cell-frame-container"], #pane-side div[tabindex]',
+  ))
+    .filter((node) => node instanceof HTMLElement)
+    .filter((node) => {
+      if (!isVisible(node) || uniqueContainers.has(node)) {
+        return false;
+      }
+      uniqueContainers.add(node);
+      return true;
+    });
+
+  const conversations = containers.map((container) => {
+    const titleCandidates = Array.from(container.querySelectorAll('span[title], div[title]'))
+      .filter((node) => node instanceof HTMLElement)
+      .filter((node) => isVisible(node))
+      .map((node) => {
+        const text = String(node.getAttribute("title") || node.textContent || "").trim();
+        const score = text ? (normalize(text).length >= 2 ? 100 : 0) : 0;
+        return { text, score };
+      })
+      .filter((item) => item.score > 0)
+      .sort((left, right) => right.score - left.score);
+
+    const contact = String(titleCandidates[0]?.text || "").trim();
+    if (!contact) {
+      return null;
+    }
+
+    const lines = String(container.innerText || "")
+      .split(/\\n+/)
+      .map((item) => item.trim())
+      .filter(Boolean);
+    const preview = lines.find((line) => normalize(line) !== normalize(contact) && !/^\\d+$/.test(line)) || "";
+
+    const unreadSources = [
+      ...Array.from(container.querySelectorAll('[aria-label*="unread"], [aria-label*="Unread"], [aria-label*="não l"], [data-testid*="unread"], [data-icon*="unread"]')),
+      container,
+    ];
+    let unreadCount = 0;
+    for (const source of unreadSources) {
+      if (!(source instanceof HTMLElement)) {
+        continue;
+      }
+      const label = \`\${source.getAttribute("aria-label") || ""} \${source.innerText || ""}\`.trim();
+      const lower = normalize(label);
+      if (!lower || (!lower.includes("unread") && !lower.includes("nao l") && !lower.includes("não l") && !/^\\d+$/.test(lower))) {
+        continue;
+      }
+      const match = label.match(/(\\d{1,3})/);
+      if (match) {
+        unreadCount = Math.max(unreadCount, Number(match[1] || 0));
+      } else if (lower.includes("unread") || lower.includes("nao l") || lower.includes("não l")) {
+        unreadCount = Math.max(unreadCount, 1);
+      }
+    }
+
+    return {
+      contact,
+      preview: String(preview || "").slice(0, 240),
+      unreadCount,
+    };
+  }).filter((item) => item !== null);
+
+  const deduped = new Map();
+  for (const item of conversations) {
+    const key = normalize(item.contact);
+    const current = deduped.get(key);
+    if (!current || item.unreadCount > current.unreadCount || item.preview.length > current.preview.length) {
+      deduped.set(key, item);
+    }
+  }
+
+  return {
+    conversations: Array.from(deduped.values())
+      .filter((item) => !unreadOnly || item.unreadCount > 0)
+      .sort((left, right) => right.unreadCount - left.unreadCount || left.contact.localeCompare(right.contact))
+      .slice(0, maxItems),
+  };
+})()
+    `);
+        const rawConversations = Array.isArray(result.conversations)
+            ? result.conversations
+            : [];
+        return rawConversations
+            .map((item) => ({
+            contact: String(item.contact || "").trim().slice(0, 120),
+            preview: String(item.preview || "").trim().slice(0, 240),
+            unreadCount: Math.max(0, Number(item.unreadCount || 0)),
+        }))
+            .filter((item) => item.contact);
+    }
     async verifyLastMessage(expectedText, previousMessages) {
         const baseline = Array.isArray(previousMessages) ? previousMessages : [];
         const chat = await this.readVisibleConversation(Math.max(8, baseline.length + 2));