@leg3ndy/otto-bridge 0.6.10 → 0.7.2

package/README.md

@@ -33,10 +33,12 @@ Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./leg3ndy-otto-bridge-0.6.10.tgz
+npm install -g ./leg3ndy-otto-bridge-0.7.2.tgz
 ```
 
-No `0.6.10`, `playwright` deixa de ser opcional no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
+No `0.7.2`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
+
+No macOS, o `0.7.2` passa a preferir o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper agora sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. Se voce quiser forcar o runtime antigo com Chromium/Playwright, use `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
 
 ## Publicacao
 
@@ -106,7 +108,7 @@ otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
 
 ### WhatsApp Web em background
 
-Fluxo recomendado no `0.6.10`:
+Fluxo recomendado no `0.7.2`:
 
 ```bash
 otto-bridge extensions --install whatsappweb
@@ -114,14 +116,29 @@ otto-bridge extensions --setup whatsappweb
 otto-bridge extensions --status whatsappweb
 ```
 
-O setup agora abre o login do WhatsApp Web em um browser persistente do proprio bridge. Depois do QR code, o Otto usa a sessao local em background, sem depender de aba visivel no Safari.
+O setup agora abre o login do WhatsApp Web no helper/background browser do proprio bridge. Depois do QR code, o Otto usa a sessao local em background, sem depender de aba visivel no Safari.
 
-Contrato do `0.6.10`:
+Contrato do `0.7.2`:
 
 - `otto-bridge extensions --setup whatsappweb`: autentica a sessao uma vez
 - `otto-bridge run`: mantem o browser persistente do WhatsApp vivo em background enquanto o runtime estiver ativo, sem depender de uma aba aberta no Safari
 - ao parar o `otto-bridge run`: o browser em background e desligado, mas a sessao local fica lembrada para o proximo boot
 
+## Handoff rapido do 0.7.2
+
+Ja fechado no codigo:
+
+- provider `macos-helper` dockless no macOS com fallback para `embedded-playwright`
+- user-agent do helper ajustado para evitar bloqueio do WhatsApp por detecao de Safari/WebKit
+- resultado final dos `device_job` agora e persistido como contexto mais forte para o proximo turno do Otto
+- prompt bridge-aware no chat normal para ajudar o Otto a responder com base no que realmente aconteceu no device
+
+Ainda precisa reteste em campo:
+
+- fluxo completo do WhatsApp no helper `macos-helper`
+- confirmacao de que o helper realmente passa do gate de compatibilidade do WhatsApp
+- perguntas de follow-up como `o que voce mandou?` depois de uma acao local de mensagem
+
 ### Ver estado local
 
 ```bash

package/dist/executors/native_macos.js

@@ -2452,7 +2452,9 @@ return { clicked: true };
             await backgroundBrowser.sendMessage(text);
             return;
         }
-        const result = await this.runSafariJsonScript(`
+        let result = null;
+        for (let attempt = 0; attempt < 12; attempt += 1) {
+            result = await this.runSafariJsonScript(`
 const value = String(__input?.text || "");
 function isVisible(element) {
   if (!(element instanceof HTMLElement)) return false;
@@ -2463,6 +2465,10 @@ function isVisible(element) {
   return rect.bottom >= 0 && rect.right >= 0 && rect.top <= window.innerHeight && rect.left <= window.innerWidth;
 }
 
+function normalize(value) {
+  return String(value || "").normalize("NFD").replace(/[\\u0300-\\u036f]/g, "").toLowerCase().trim();
+}
+
 function clearAndFillComposer(element, nextValue) {
   element.focus();
   if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
@@ -2486,17 +2492,53 @@ function clearAndFillComposer(element, nextValue) {
   element.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: nextValue }));
 }
 
-const candidates = Array.from(document.querySelectorAll('footer div[contenteditable="true"], [data-testid="conversation-compose-box-input"], main footer [contenteditable="true"], footer textarea'))
-  .filter((node) => node instanceof HTMLElement)
-  .filter((node) => isVisible(node))
-  .sort((left, right) => right.getBoundingClientRect().top - left.getBoundingClientRect().top);
+const uniqueTargets = new Set();
+const candidates = Array.from(document.querySelectorAll('[data-testid="conversation-compose-box-input"], footer div[contenteditable="true"], main footer [contenteditable="true"], footer textarea, div[contenteditable="true"][role="textbox"], div[contenteditable="true"][data-tab], textarea'))
+  .map((node) => {
+    if (!(node instanceof HTMLElement)) return null;
+    const resolved = node.matches('[data-testid="conversation-compose-box-input"]')
+      ? node.querySelector('[contenteditable="true"], textarea')
+      : node;
+    return resolved instanceof HTMLElement ? resolved : null;
+  })
+  .filter((node) => {
+    if (!(node instanceof HTMLElement) || uniqueTargets.has(node) || !isVisible(node)) {
+      return false;
+    }
+    uniqueTargets.add(node);
+    return true;
+  })
+  .map((node) => {
+    const rect = node.getBoundingClientRect();
+    const label = normalize(
+      node.getAttribute("aria-label")
+      || node.getAttribute("aria-placeholder")
+      || node.getAttribute("placeholder")
+      || node.getAttribute("data-testid")
+      || node.textContent
+      || ""
+    );
+    let score = 0;
+    if (node.closest("footer")) score += 120;
+    if (node.closest("main")) score += 60;
+    if (rect.top > window.innerHeight * 0.55) score += 80;
+    if (rect.left > window.innerWidth * 0.2) score += 30;
+    if (label.includes("mensagem") || label.includes("message") || label.includes("digite") || label.includes("type")) score += 160;
+    if (label.includes("search") || label.includes("pesquisar") || label.includes("procure") || label.includes("chat list")) score -= 240;
+    if (node.closest('[data-testid="chat-list-search"], [role="search"]')) score -= 260;
+    if (rect.top < 240) score -= 80;
+    return { node, score };
+  })
+  .filter((item) => item.score > 0)
+  .sort((left, right) => right.score - left.score || right.node.getBoundingClientRect().top - left.node.getBoundingClientRect().top);
 
 if (!candidates.length) {
   return { sent: false, reason: "Nao achei o campo de mensagem do WhatsApp Web." };
 }
 
-const composer = candidates[0];
+const composer = candidates[0].node;
 clearAndFillComposer(composer, value);
+composer.focus();
 composer.click();
 
 const sendCandidates = Array.from(document.querySelectorAll('[data-testid="compose-btn-send"], button[aria-label*="Send"], button[aria-label*="Enviar"], span[data-icon="send"], div[role="button"][aria-label*="Send"], div[role="button"][aria-label*="Enviar"]'))
@@ -2519,7 +2561,12 @@ composer.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", code: "Enter
 composer.dispatchEvent(new KeyboardEvent("keypress", { key: "Enter", code: "Enter", keyCode: 13, which: 13, bubbles: true }));
 composer.dispatchEvent(new KeyboardEvent("keyup", { key: "Enter", code: "Enter", keyCode: 13, which: 13, bubbles: true }));
 return { sent: true };
-      `, { text }, this.getWhatsAppWebScriptOptions(false));
+        `, { text }, this.getWhatsAppWebScriptOptions(false));
+            if (result?.sent) {
+                break;
+            }
+            await delay(500);
+        }
         if (!result?.sent) {
             throw new Error(result?.reason || "Nao consegui enviar a mensagem no WhatsApp Web.");
         }

package/dist/macos_whatsapp_helper.js

@@ -0,0 +1,590 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { getBridgeHomeDir } from "./config.js";
+import { MACOS_WHATSAPP_HELPER_SWIFT_SOURCE } from "./macos_whatsapp_helper_source.js";
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeText(value) {
+    return String(value || "")
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .trim();
+}
+async function runHelperCommand(command, args) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve(stdout.trim() || stderr.trim());
+                return;
+            }
+            reject(new Error(stderr.trim() || stdout.trim() || `${command} exited with code ${code}`));
+        });
+    });
+}
+export async function checkMacOSWhatsAppHelperAvailability() {
+    if (process.platform !== "darwin") {
+        return {
+            ok: false,
+            reason: "O helper dockless do WhatsApp so esta disponivel no macOS.",
+        };
+    }
+    try {
+        await runHelperCommand("swift", ["--version"]);
+        return { ok: true };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function ensureHelperScriptPath() {
+    const helperDir = path.join(getBridgeHomeDir(), "runtime");
+    await mkdir(helperDir, { recursive: true });
+    const helperPath = path.join(helperDir, "otto_whatsapp_helper.swift");
+    await writeFile(helperPath, MACOS_WHATSAPP_HELPER_SWIFT_SOURCE, "utf8");
+    return helperPath;
+}
+export class MacOSWhatsAppHelperRuntime {
+    options;
+    child = null;
+    stdoutBuffer = "";
+    pending = new Map();
+    started = false;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async start() {
+        if (this.started && this.child) {
+            return;
+        }
+        const helperScriptPath = await ensureHelperScriptPath();
+        this.child = spawn("swift", [helperScriptPath], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child.stdout.setEncoding("utf8");
+        this.child.stderr.setEncoding("utf8");
+        this.child.stdout.on("data", (chunk) => this.handleStdout(String(chunk)));
+        this.child.stderr.on("data", () => undefined);
+        this.child.on("exit", () => {
+            const error = new Error("Helper do WhatsApp foi encerrado.");
+            for (const pending of this.pending.values()) {
+                pending.reject(error);
+            }
+            this.pending.clear();
+            this.child = null;
+            this.started = false;
+        });
+        await this.waitForReady();
+        this.started = true;
+        await this.call("load_whatsapp");
+        if (this.options.background) {
+            await this.call("hide_background");
+        }
+    }
+    async close() {
+        const child = this.child;
+        if (!child) {
+            return;
+        }
+        try {
+            await this.call("close");
+        }
+        catch {
+            child.kill();
+        }
+        finally {
+            this.child = null;
+            this.started = false;
+        }
+    }
+    async waitForTimeout(timeout) {
+        await delay(Math.max(0, timeout));
+    }
+    async showSetup() {
+        await this.start();
+        await this.call("show_setup");
+    }
+    async hideBackground() {
+        await this.start();
+        await this.call("hide_background");
+    }
+    async evaluate(script) {
+        await this.start();
+        return await this.call("evaluate_js", { script });
+    }
+    async getSessionState() {
+        const state = await this.evaluate(`
+(() => {
+  function isVisible(element) {
+    if (!(element instanceof HTMLElement)) return false;
+    const rect = element.getBoundingClientRect();
+    if (rect.width < 4 || rect.height < 4) 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 qrVisible = Array.from(document.querySelectorAll('[data-testid="qrcode"], canvas[aria-label*="Scan"], canvas[aria-label*="scan"], div[data-ref] canvas'))
+    .some((node) => isVisible(node));
+  const paneVisible = Array.from(document.querySelectorAll('#pane-side, [data-testid="chat-list"]'))
+    .some((node) => isVisible(node));
+  const searchVisible = Array.from(document.querySelectorAll('[data-testid="chat-list-search"] [contenteditable="true"], div[contenteditable="true"][role="textbox"]'))
+    .some((node) => isVisible(node));
+  const composerVisible = Array.from(document.querySelectorAll('footer [contenteditable="true"], [data-testid="conversation-compose-box-input"]'))
+    .some((node) => isVisible(node));
+
+  return {
+    title: document.title || "",
+    url: location.href || "",
+    qrVisible,
+    paneVisible,
+    searchVisible,
+    composerVisible,
+    connected: paneVisible || searchVisible || composerVisible,
+  };
+})()
+    `);
+        return {
+            title: String(state.title || ""),
+            url: String(state.url || ""),
+            qrVisible: state.qrVisible === true,
+            paneVisible: state.paneVisible === true,
+            searchVisible: state.searchVisible === true,
+            composerVisible: state.composerVisible === true,
+            connected: state.connected === true,
+        };
+    }
+    async waitForLogin(timeoutMs) {
+        const deadline = Date.now() + Math.max(10_000, timeoutMs);
+        let lastState = null;
+        while (Date.now() < deadline) {
+            lastState = await this.getSessionState();
+            if (lastState.connected) {
+                return lastState;
+            }
+            await delay(1500);
+        }
+        return lastState || await this.getSessionState();
+    }
+    async waitForStableSessionState(options) {
+        const timeoutMs = Math.max(2_000, Number(options?.timeoutMs || 15_000));
+        const pollIntervalMs = Math.max(250, Number(options?.pollIntervalMs || 1_000));
+        const qrStabilityWindowMs = Math.max(pollIntervalMs, Number(options?.qrStabilityWindowMs || 4_000));
+        const deadline = Date.now() + timeoutMs;
+        let lastState = null;
+        let qrVisibleSince = null;
+        while (Date.now() < deadline) {
+            lastState = await this.getSessionState();
+            if (lastState.connected) {
+                return lastState;
+            }
+            if (lastState.qrVisible) {
+                if (qrVisibleSince === null) {
+                    qrVisibleSince = Date.now();
+                }
+                else if (Date.now() - qrVisibleSince >= qrStabilityWindowMs) {
+                    return lastState;
+                }
+            }
+            else {
+                qrVisibleSince = null;
+            }
+            await delay(pollIntervalMs);
+        }
+        return lastState || await this.getSessionState();
+    }
+    async ensureReady() {
+        const state = await this.waitForStableSessionState({
+            timeoutMs: 45_000,
+            qrStabilityWindowMs: 10_000,
+        });
+        if (state.connected) {
+            return state;
+        }
+        if (state.qrVisible) {
+            throw new Error("WhatsApp Web ainda nao esta conectado nesta maquina. Rode `otto-bridge extensions --setup whatsappweb`, escaneie o QR code e depois `otto-bridge extensions --status whatsappweb`.");
+        }
+        throw new Error("Nao consegui confirmar uma sessao pronta do WhatsApp Web neste helper macOS em background.");
+    }
+    async selectConversation(contact) {
+        await this.ensureReady();
+        const prepared = await this.evaluate(`
+(() => {
+  const contact = ${JSON.stringify(contact)};
+  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 < 4 || rect.height < 4) 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 candidates = Array.from(document.querySelectorAll('div[contenteditable="true"][role="textbox"], input[role="textbox"], textarea, div[contenteditable="true"][data-tab], [data-testid="chat-list-search"] [contenteditable="true"]'))
+    .filter((node) => node instanceof HTMLElement)
+    .filter((node) => isVisible(node))
+    .map((node) => {
+      const rect = node.getBoundingClientRect();
+      const label = normalize(node.getAttribute("aria-label") || node.getAttribute("data-testid") || node.textContent || "");
+      let score = 0;
+      if (rect.left < window.innerWidth * 0.45) score += 30;
+      if (rect.top < 240) score += 30;
+      if (label.includes("search") || label.includes("pesquisar") || label.includes("procure") || label.includes("chat list")) score += 80;
+      if (node.closest('[data-testid="chat-list-search"], header')) score += 25;
+      return { node, score };
+    })
+    .sort((left, right) => right.score - left.score);
+
+  if (!candidates.length) {
+    return { ok: false, reason: "Nao achei o campo de busca do WhatsApp Web." };
+  }
+
+  const searchBox = candidates[0].node;
+  searchBox.focus();
+
+  if (searchBox instanceof HTMLInputElement || searchBox instanceof HTMLTextAreaElement) {
+    searchBox.value = "";
+    searchBox.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "deleteContentBackward", data: null }));
+    searchBox.value = contact;
+    searchBox.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: contact }));
+  } else {
+    const selection = window.getSelection();
+    const range = document.createRange();
+    range.selectNodeContents(searchBox);
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+    document.execCommand("selectAll", false);
+    document.execCommand("delete", false);
+    document.execCommand("insertText", false, contact);
+    if ((searchBox.innerText || "").trim() !== contact.trim()) {
+      searchBox.textContent = contact;
+    }
+    searchBox.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: contact }));
+  }
+
+  return { ok: true };
+})()
+    `);
+        if (!(prepared.ok === true)) {
+            return false;
+        }
+        const deadline = Date.now() + 6_000;
+        while (Date.now() < deadline) {
+            await delay(500);
+            const result = await this.evaluate(`
+(() => {
+  const query = ${JSON.stringify(contact)};
+  const normalize = (value) => String(value || "").normalize("NFD").replace(/[\\u0300-\\u036f]/g, "").toLowerCase().trim();
+  const normalizedQuery = normalize(query);
+
+  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 titleNodes = Array.from(document.querySelectorAll('span[title], div[title]'))
+    .filter((node) => node instanceof HTMLElement)
+    .filter((node) => isVisible(node))
+    .map((node) => {
+      const text = normalize(node.getAttribute("title") || node.textContent || "");
+      let score = 0;
+      if (text === normalizedQuery) score += 160;
+      if (text.includes(normalizedQuery)) score += 100;
+      if (normalizedQuery.includes(text) && text.length >= 3) score += 50;
+      const container = node.closest('[data-testid="cell-frame-container"], [role="listitem"], [role="gridcell"], div[tabindex]');
+      if (container instanceof HTMLElement && isVisible(container)) score += 20;
+      return { node, container, score };
+    })
+    .filter((item) => item.score > 0)
+    .sort((left, right) => right.score - left.score);
+
+  if (!titleNodes.length) {
+    return { clicked: false };
+  }
+
+  const winner = titleNodes[0];
+  const target = winner.container instanceof HTMLElement ? winner.container : winner.node;
+  target.scrollIntoView({ block: "center", inline: "center", behavior: "auto" });
+  if (typeof target.click === "function") {
+    target.click();
+    return { clicked: true };
+  }
+  target.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true, view: window }));
+  return { clicked: true };
+})()
+      `);
+            if (result.clicked === true) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async sendMessage(text) {
+        await this.ensureReady();
+        let result = null;
+        for (let attempt = 0; attempt < 12; attempt += 1) {
+            result = await this.evaluate(`
+(() => {
+  const value = ${JSON.stringify(text)};
+  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 uniqueTargets = new Set();
+  const candidates = Array.from(document.querySelectorAll('[data-testid="conversation-compose-box-input"], footer div[contenteditable="true"], main footer [contenteditable="true"], footer textarea, div[contenteditable="true"][role="textbox"], div[contenteditable="true"][data-tab], textarea'))
+    .map((node) => {
+      if (!(node instanceof HTMLElement)) return null;
+      const resolved = node.matches('[data-testid="conversation-compose-box-input"]')
+        ? node.querySelector('[contenteditable="true"], textarea')
+        : node;
+      return resolved instanceof HTMLElement ? resolved : null;
+    })
+    .filter((node) => {
+      if (!(node instanceof HTMLElement) || uniqueTargets.has(node) || !isVisible(node)) {
+        return false;
+      }
+      uniqueTargets.add(node);
+      return true;
+    })
+    .map((node) => {
+      const rect = node.getBoundingClientRect();
+      const label = normalize(node.getAttribute("aria-label") || node.getAttribute("aria-placeholder") || node.getAttribute("placeholder") || node.getAttribute("data-testid") || node.textContent || "");
+      let score = 0;
+      if (node.closest("footer")) score += 120;
+      if (node.closest("main")) score += 60;
+      if (rect.top > window.innerHeight * 0.55) score += 80;
+      if (rect.left > window.innerWidth * 0.2) score += 30;
+      if (label.includes("mensagem") || label.includes("message") || label.includes("digite") || label.includes("type")) score += 160;
+      if (label.includes("search") || label.includes("pesquisar") || label.includes("procure") || label.includes("chat list")) score -= 240;
+      if (node.closest('[data-testid="chat-list-search"], [role="search"]')) score -= 260;
+      if (rect.top < 240) score -= 80;
+      return { node, score };
+    })
+    .filter((item) => item.score > 0)
+    .sort((left, right) => right.score - left.score || right.node.getBoundingClientRect().top - left.node.getBoundingClientRect().top);
+
+  if (!candidates.length) {
+    return { sent: false, reason: "Nao achei o campo de mensagem do WhatsApp Web." };
+  }
+
+  const composer = candidates[0].node;
+  composer.focus();
+  if (composer instanceof HTMLInputElement || composer instanceof HTMLTextAreaElement) {
+    composer.value = "";
+    composer.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "deleteContentBackward", data: null }));
+    composer.value = value;
+    composer.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: value }));
+  } else {
+    const selection = window.getSelection();
+    const range = document.createRange();
+    range.selectNodeContents(composer);
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+    document.execCommand("selectAll", false);
+    document.execCommand("delete", false);
+    document.execCommand("insertText", false, value);
+    if ((composer.innerText || "").trim() !== value.trim()) {
+      composer.textContent = value;
+    }
+    composer.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: value }));
+  }
+  composer.click();
+
+  const sendCandidates = Array.from(document.querySelectorAll('[data-testid="compose-btn-send"], button[aria-label*="Send"], button[aria-label*="Enviar"], span[data-icon="send"], div[role="button"][aria-label*="Send"], div[role="button"][aria-label*="Enviar"]'))
+    .map((node) => node instanceof HTMLElement ? (node.closest('button, div[role="button"]') || node) : null)
+    .filter((node) => node instanceof HTMLElement)
+    .filter((node) => isVisible(node));
+
+  const sendButton = sendCandidates[0];
+  if (sendButton instanceof HTMLElement) {
+    sendButton.scrollIntoView({ block: "center", inline: "center", behavior: "auto" });
+    if (typeof sendButton.click === "function") {
+      sendButton.click();
+      return { sent: true };
+    }
+    sendButton.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true, view: window }));
+    return { sent: true };
+  }
+
+  composer.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", code: "Enter", keyCode: 13, which: 13, bubbles: true }));
+  composer.dispatchEvent(new KeyboardEvent("keypress", { key: "Enter", code: "Enter", keyCode: 13, which: 13, bubbles: true }));
+  composer.dispatchEvent(new KeyboardEvent("keyup", { key: "Enter", code: "Enter", keyCode: 13, which: 13, bubbles: true }));
+  return { sent: true };
+})()
+      `);
+            if (result.sent === true) {
+                return;
+            }
+            await delay(500);
+        }
+        throw new Error(String(result?.reason || "Nao consegui enviar a mensagem no WhatsApp Web."));
+    }
+    async readVisibleConversation(limit) {
+        await this.ensureReady();
+        const result = await this.evaluate(`
+(() => {
+  const maxMessages = ${Math.max(1, Number(limit || 12))};
+
+  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 containers = Array.from(document.querySelectorAll('[data-testid="msg-container"], div[data-id]'))
+    .filter((node) => node instanceof HTMLElement)
+    .filter((node) => isVisible(node));
+
+  const messages = containers.map((element) => {
+    const prePlain = element.querySelector('[data-pre-plain-text]')?.getAttribute("data-pre-plain-text") || "";
+    const authorMatch = prePlain.match(/\\]\\s*([^:]+):/);
+    const author = authorMatch?.[1]?.trim() || (element.getAttribute("data-testid")?.includes("out") ? "Voce" : "Contato");
+    const text = (element.innerText || "").trim().replace(/\\n{2,}/g, "\\n");
+    return { author, text };
+  }).filter((item) => item.text);
+
+  return { messages: messages.slice(-maxMessages) };
+})()
+    `);
+        const rawMessages = Array.isArray(result.messages)
+            ? result.messages
+            : [];
+        const messages = rawMessages
+            .map((item) => ({
+            author: String(item.author || "Contato").trim().slice(0, 80),
+            text: String(item.text || "").trim().slice(0, 500),
+        }))
+            .filter((item) => item.text);
+        return {
+            messages,
+            summary: messages.length
+                ? messages.map((item) => `${item.author}: ${item.text}`).join("\n")
+                : "(sem mensagens visiveis na conversa)",
+        };
+    }
+    async verifyLastMessage(expectedText) {
+        const chat = await this.readVisibleConversation(6);
+        if (!chat.messages.length) {
+            return {
+                ok: false,
+                reason: "Nao consegui ler as mensagens visiveis apos o envio no WhatsApp.",
+            };
+        }
+        const normalizedExpected = normalizeText(expectedText).slice(0, 60);
+        const matched = chat.messages.some((item) => normalizeText(item.text).includes(normalizedExpected));
+        if (!matched) {
+            return {
+                ok: false,
+                reason: "Nao consegui confirmar na conversa do WhatsApp se a mensagem foi enviada.",
+            };
+        }
+        return { ok: true, reason: "" };
+    }
+    handleStdout(chunk) {
+        this.stdoutBuffer += chunk;
+        while (true) {
+            const newlineIndex = this.stdoutBuffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                break;
+            }
+            const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+            this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+            if (!line) {
+                continue;
+            }
+            let parsed = null;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.event === "ready") {
+                const pending = this.pending.get("__ready__");
+                if (pending) {
+                    this.pending.delete("__ready__");
+                    pending.resolve(true);
+                }
+                continue;
+            }
+            const id = String(parsed.id || "");
+            if (!id) {
+                continue;
+            }
+            const pending = this.pending.get(id);
+            if (!pending) {
+                continue;
+            }
+            this.pending.delete(id);
+            if (parsed.ok === true) {
+                pending.resolve(parsed.result);
+            }
+            else {
+                pending.reject(new Error(String(parsed.error || "Falha no helper do WhatsApp.")));
+            }
+        }
+    }
+    async waitForReady() {
+        await new Promise((resolve, reject) => {
+            this.pending.set("__ready__", { resolve: () => resolve(), reject });
+            setTimeout(() => {
+                if (this.pending.has("__ready__")) {
+                    this.pending.delete("__ready__");
+                    reject(new Error("Helper do WhatsApp demorou demais para iniciar."));
+                }
+            }, 20_000);
+        });
+    }
+    async call(method, params) {
+        const child = this.child;
+        if (!child) {
+            throw new Error("Helper do WhatsApp nao esta em execucao.");
+        }
+        const id = randomUUID();
+        const payload = JSON.stringify({ id, method, params: params || {} }) + "\n";
+        const promise = new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`Helper do WhatsApp demorou demais para responder ao metodo ${method}.`));
+                }
+            }, 30_000);
+        });
+        child.stdin.write(payload, "utf8");
+        return await promise;
+    }
+}

package/dist/macos_whatsapp_helper_source.js

@@ -0,0 +1,176 @@
+export const MACOS_WHATSAPP_HELPER_SWIFT_SOURCE = String.raw `import AppKit
+import Foundation
+import WebKit
+
+final class OttoWhatsAppHelper: NSObject, WKNavigationDelegate {
+  private static let chromeUserAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36"
+  private let app = NSApplication.shared
+  private let window: NSWindow
+  private let webView: WKWebView
+  private var stdinBuffer = Data()
+  private let stdoutHandle = FileHandle.standardOutput
+
+  override init() {
+    let config = WKWebViewConfiguration()
+    config.websiteDataStore = .default()
+    self.webView = WKWebView(frame: .zero, configuration: config)
+    self.window = NSWindow(
+      contentRect: NSRect(x: -2200, y: 80, width: 1320, height: 920),
+      styleMask: [.titled, .closable, .miniaturizable, .resizable],
+      backing: .buffered,
+      defer: false
+    )
+    super.init()
+    app.setActivationPolicy(.accessory)
+    window.title = "Otto WhatsApp Helper"
+    window.isReleasedWhenClosed = false
+    window.contentView = webView
+    webView.navigationDelegate = self
+    webView.customUserAgent = Self.chromeUserAgent
+  }
+
+  func run() {
+    setupStdin()
+    send(["event": "ready"])
+    DispatchQueue.main.async {
+      self.ensureWhatsAppLoaded()
+      self.hideBackground()
+    }
+    app.run()
+  }
+
+  private func setupStdin() {
+    let handle = FileHandle.standardInput
+    handle.readabilityHandler = { [weak self] readable in
+      let data = readable.availableData
+      guard let self = self else { return }
+      if data.isEmpty {
+        DispatchQueue.main.async {
+          NSApp.terminate(nil)
+        }
+        return
+      }
+      self.stdinBuffer.append(data)
+      while let newlineRange = self.stdinBuffer.firstRange(of: Data([0x0A])) {
+        let lineData = self.stdinBuffer.subdata(in: 0..<newlineRange.lowerBound)
+        self.stdinBuffer.removeSubrange(0...newlineRange.lowerBound)
+        self.handleLine(lineData)
+      }
+    }
+  }
+
+  private func handleLine(_ lineData: Data) {
+    guard !lineData.isEmpty else { return }
+    guard
+      let object = try? JSONSerialization.jsonObject(with: lineData),
+      let request = object as? [String: Any],
+      let id = request["id"] as? String,
+      let method = request["method"] as? String
+    else {
+      return
+    }
+
+    let params = request["params"] as? [String: Any] ?? [:]
+    DispatchQueue.main.async {
+      self.handleRequest(id: id, method: method, params: params)
+    }
+  }
+
+  private func handleRequest(id: String, method: String, params: [String: Any]) {
+    switch method {
+    case "ping":
+      sendResponse(id: id, result: ["ok": true])
+    case "show_setup":
+      showSetup()
+      sendResponse(id: id, result: ["visible": true])
+    case "hide_background":
+      hideBackground()
+      sendResponse(id: id, result: ["background": true])
+    case "load_whatsapp":
+      ensureWhatsAppLoaded()
+      sendResponse(id: id, result: ["url": webView.url?.absoluteString ?? ""])
+    case "evaluate_js":
+      let script = String(describing: params["script"] ?? "")
+      evaluateJavaScript(script) { result, error in
+        if let error = error {
+          self.sendResponse(id: id, error: error.localizedDescription)
+          return
+        }
+        self.sendResponse(id: id, result: self.makeJSONCompatible(result))
+      }
+    case "close":
+      sendResponse(id: id, result: ["closing": true])
+      NSApp.terminate(nil)
+    default:
+      sendResponse(id: id, error: "Metodo desconhecido: \(method)")
+    }
+  }
+
+  private func ensureWhatsAppLoaded() {
+    if let current = webView.url?.absoluteString.lowercased(), current.hasPrefix("https://web.whatsapp.com") {
+      return
+    }
+    if let url = URL(string: "https://web.whatsapp.com") {
+      webView.load(URLRequest(url: url))
+    }
+  }
+
+  private func showSetup() {
+    if let screen = NSScreen.main {
+      let frame = screen.visibleFrame
+      let originX = frame.origin.x + max(0, (frame.width - 1320) / 2)
+      let originY = frame.origin.y + max(0, (frame.height - 920) / 2)
+      window.setFrame(NSRect(x: originX, y: originY, width: 1320, height: 920), display: true)
+    } else {
+      window.setFrame(NSRect(x: 120, y: 120, width: 1320, height: 920), display: true)
+    }
+    window.orderFrontRegardless()
+    app.activate(ignoringOtherApps: true)
+  }
+
+  private func hideBackground() {
+    window.setFrame(NSRect(x: -2200, y: 80, width: 1320, height: 920), display: true)
+    window.orderFrontRegardless()
+  }
+
+  private func evaluateJavaScript(_ script: String, completion: @escaping (Any?, Error?) -> Void) {
+    webView.evaluateJavaScript(script) { result, error in
+      completion(result, error)
+    }
+  }
+
+  private func makeJSONCompatible(_ value: Any?) -> Any {
+    guard let value = value else { return NSNull() }
+    switch value {
+    case is NSString, is NSNumber, is NSNull:
+      return value
+    case let dict as [String: Any]:
+      return dict.mapValues { makeJSONCompatible($0) }
+    case let array as [Any]:
+      return array.map { makeJSONCompatible($0) }
+    default:
+      return String(describing: value)
+    }
+  }
+
+  private func sendResponse(id: String, result: Any? = nil, error: String? = nil) {
+    var payload: [String: Any] = ["id": id, "ok": error == nil]
+    if let error = error {
+      payload["error"] = error
+    } else {
+      payload["result"] = makeJSONCompatible(result)
+    }
+    send(payload)
+  }
+
+  private func send(_ object: [String: Any]) {
+    guard let data = try? JSONSerialization.data(withJSONObject: object) else { return }
+    var line = data
+    line.append(0x0A)
+    try? stdoutHandle.write(contentsOf: line)
+  }
+}
+
+let helper = OttoWhatsAppHelper()
+helper.run()
+`;

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "0.6.10";
+export const BRIDGE_VERSION = "0.7.2";
 export const BRIDGE_PACKAGE_NAME = "@leg3ndy/otto-bridge";
 export const DEFAULT_API_BASE_URL = "http://localhost:8000";
 export const DEFAULT_POLL_INTERVAL_MS = 3000;

package/dist/whatsapp_background.js

@@ -1,8 +1,11 @@
 import { spawn } from "node:child_process";
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
+import process from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { getBridgeHomeDir } from "./config.js";
+import { checkMacOSWhatsAppHelperAvailability, MacOSWhatsAppHelperRuntime, } from "./macos_whatsapp_helper.js";
+import { getConfiguredWhatsAppRuntimeProvider } from "./whatsapp_runtime_provider.js";
 export const WHATSAPP_WEB_URL = "https://web.whatsapp.com";
 const DEFAULT_SETUP_TIMEOUT_MS = 5 * 60 * 1000;
 const DEFAULT_SESSION_SETTLE_TIMEOUT_MS = 15_000;
@@ -25,7 +28,7 @@ function playwrightImportCandidates() {
     ];
     return Array.from(new Set(candidates));
 }
-async function loadPlaywrightModule() {
+async function loadEmbeddedPlaywrightModule() {
     const errors = [];
     for (const candidate of playwrightImportCandidates()) {
         try {
@@ -78,12 +81,24 @@ export class WhatsAppBackgroundBrowser {
     options;
     context = null;
     page = null;
+    helperRuntime = null;
+    activeProviderKind = null;
     constructor(options = {}) {
         this.options = options;
     }
     static async checkAvailability() {
+        const provider = getConfiguredWhatsAppRuntimeProvider();
+        if (provider.kind === "macos-helper") {
+            const helperAvailability = await checkMacOSWhatsAppHelperAvailability();
+            if (helperAvailability.ok) {
+                return helperAvailability;
+            }
+            if (provider.source === "env") {
+                return helperAvailability;
+            }
+        }
         try {
-            await loadPlaywrightModule();
+            await loadEmbeddedPlaywrightModule();
             return { ok: true };
         }
         catch (error) {
@@ -94,10 +109,39 @@ export class WhatsAppBackgroundBrowser {
         }
     }
     async start() {
-        if (this.context && this.page) {
+        if (this.helperRuntime || (this.context && this.page)) {
             return;
         }
-        const playwright = await loadPlaywrightModule();
+        const provider = getConfiguredWhatsAppRuntimeProvider();
+        if (provider.kind === "macos-helper" && process.platform === "darwin") {
+            const helperAvailability = await checkMacOSWhatsAppHelperAvailability();
+            if (helperAvailability.ok) {
+                try {
+                    this.helperRuntime = new MacOSWhatsAppHelperRuntime({ background: this.options.background });
+                    await this.helperRuntime.start();
+                    if (this.options.background) {
+                        await this.helperRuntime.hideBackground();
+                    }
+                    else {
+                        await this.helperRuntime.showSetup();
+                    }
+                    this.activeProviderKind = "macos-helper";
+                    return;
+                }
+                catch (error) {
+                    this.helperRuntime = null;
+                    if (provider.source === "env") {
+                        throw error;
+                    }
+                    const detail = error instanceof Error ? error.message : String(error);
+                    console.warn(`[otto-bridge] whatsapp runtime fallback para embedded-playwright: ${detail}`);
+                }
+            }
+            else if (provider.source === "env") {
+                throw new Error(helperAvailability.reason || "O helper macOS do WhatsApp nao esta disponivel nesta maquina.");
+            }
+        }
+        const playwright = await loadEmbeddedPlaywrightModule();
         await ensureWhatsAppBrowserUserDataDir();
         this.context = await playwright.chromium.launchPersistentContext(getWhatsAppBrowserUserDataDir(), {
             headless: this.options.headless === true,
@@ -114,20 +158,31 @@ export class WhatsAppBackgroundBrowser {
         const pages = this.context.pages();
         this.page = pages[0] || await this.context.newPage();
         await this.ensureWhatsAppPage();
+        this.activeProviderKind = "embedded-playwright";
         if (this.options.background) {
             await this.ensureBackgroundPlacement();
         }
     }
     async close() {
+        const helper = this.helperRuntime;
+        this.helperRuntime = null;
         const current = this.context;
         this.page = null;
         this.context = null;
+        this.activeProviderKind = null;
+        if (helper) {
+            await helper.close().catch(() => undefined);
+        }
         if (!current) {
             return;
         }
         await current.close().catch(() => undefined);
     }
     async waitForTimeout(timeoutMs) {
+        if (this.helperRuntime) {
+            await this.helperRuntime.waitForTimeout(timeoutMs);
+            return;
+        }
         await this.page?.waitForTimeout(Math.max(0, Number(timeoutMs || 0)));
     }
     async ensureBackgroundPlacement() {
@@ -228,6 +283,9 @@ export class WhatsAppBackgroundBrowser {
         return candidates[0]?.pid || null;
     }
     async getSessionState() {
+        if (this.helperRuntime) {
+            return await this.helperRuntime.getSessionState();
+        }
         const state = await this.withPage(async (page) => {
             await this.ensureWhatsAppPage();
             return page.evaluate(() => {
@@ -272,6 +330,9 @@ export class WhatsAppBackgroundBrowser {
         };
     }
     async ensureReady() {
+        if (this.helperRuntime) {
+            return await this.helperRuntime.ensureReady();
+        }
         const state = await this.waitForStableSessionState();
         if (state.connected) {
             return state;
@@ -282,6 +343,9 @@ export class WhatsAppBackgroundBrowser {
         throw new Error("Nao consegui confirmar uma sessao pronta do WhatsApp Web neste browser em background.");
     }
     async waitForLogin(timeoutMs = DEFAULT_SETUP_TIMEOUT_MS) {
+        if (this.helperRuntime) {
+            return await this.helperRuntime.waitForLogin(timeoutMs);
+        }
         const deadline = Date.now() + Math.max(10_000, timeoutMs);
         let lastState = null;
         while (Date.now() < deadline) {
@@ -294,6 +358,9 @@ export class WhatsAppBackgroundBrowser {
         return lastState || await this.getSessionState();
     }
     async waitForStableSessionState(options) {
+        if (this.helperRuntime) {
+            return await this.helperRuntime.waitForStableSessionState(options);
+        }
         const timeoutMs = Math.max(2_000, Number(options?.timeoutMs || DEFAULT_SESSION_SETTLE_TIMEOUT_MS));
         const pollIntervalMs = Math.max(250, Number(options?.pollIntervalMs || DEFAULT_SESSION_POLL_INTERVAL_MS));
         const qrStabilityWindowMs = Math.max(pollIntervalMs, Number(options?.qrStabilityWindowMs || DEFAULT_QR_STABILITY_WINDOW_MS));
@@ -321,6 +388,9 @@ export class WhatsAppBackgroundBrowser {
         return lastState || await this.getSessionState();
     }
     async selectConversation(contact) {
+        if (this.helperRuntime) {
+            return await this.helperRuntime.selectConversation(contact);
+        }
         await this.ensureReady();
         const prepared = await this.withPage(async (page) => {
             const focusResult = await page.evaluate(() => {
@@ -453,32 +523,88 @@ export class WhatsAppBackgroundBrowser {
         return false;
     }
     async sendMessage(text) {
+        if (this.helperRuntime) {
+            await this.helperRuntime.sendMessage(text);
+            return;
+        }
         await this.ensureReady();
         const result = await this.withPage(async (page) => {
-            const focusedComposer = await page.evaluate(() => {
-                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 candidates = Array.from(document.querySelectorAll('footer div[contenteditable="true"], [data-testid="conversation-compose-box-input"], main footer [contenteditable="true"], footer textarea'))
-                    .filter((node) => node instanceof HTMLElement)
-                    .filter((node) => isVisible(node))
-                    .sort((left, right) => right.getBoundingClientRect().top - left.getBoundingClientRect().top);
-                if (!candidates.length) {
-                    return { ok: false, reason: "Nao achei o campo de mensagem do WhatsApp Web." };
+            let focusedComposer = { ok: false };
+            const deadline = Date.now() + 8_000;
+            while (Date.now() < deadline) {
+                focusedComposer = await page.evaluate(() => {
+                    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 uniqueTargets = new Set();
+                    const rawCandidates = Array.from(document.querySelectorAll('[data-testid="conversation-compose-box-input"], footer div[contenteditable="true"], main footer [contenteditable="true"], footer textarea, div[contenteditable="true"][role="textbox"], div[contenteditable="true"][data-tab], textarea'));
+                    const candidates = rawCandidates
+                        .map((node) => {
+                        if (!(node instanceof HTMLElement))
+                            return null;
+                        const resolved = node.matches('[data-testid="conversation-compose-box-input"]')
+                            ? node.querySelector('[contenteditable="true"], textarea')
+                            : node;
+                        return resolved instanceof HTMLElement ? resolved : null;
+                    })
+                        .filter((node) => {
+                        if (!(node instanceof HTMLElement) || uniqueTargets.has(node) || !isVisible(node)) {
+                            return false;
+                        }
+                        uniqueTargets.add(node);
+                        return true;
+                    })
+                        .map((node) => {
+                        const rect = node.getBoundingClientRect();
+                        const label = normalize(node.getAttribute("aria-label")
+                            || node.getAttribute("aria-placeholder")
+                            || node.getAttribute("placeholder")
+                            || node.getAttribute("data-testid")
+                            || node.textContent
+                            || "");
+                        let score = 0;
+                        if (node.closest("footer"))
+                            score += 120;
+                        if (node.closest("main"))
+                            score += 60;
+                        if (rect.top > window.innerHeight * 0.55)
+                            score += 80;
+                        if (rect.left > window.innerWidth * 0.2)
+                            score += 30;
+                        if (label.includes("mensagem") || label.includes("message") || label.includes("digite") || label.includes("type"))
+                            score += 160;
+                        if (label.includes("search") || label.includes("pesquisar") || label.includes("procure") || label.includes("chat list"))
+                            score -= 240;
+                        if (node.closest('[data-testid="chat-list-search"], [role="search"]'))
+                            score -= 260;
+                        if (rect.top < 240)
+                            score -= 80;
+                        return { node, score };
+                    })
+                        .filter((item) => item.score > 0)
+                        .sort((left, right) => right.score - left.score || right.node.getBoundingClientRect().top - left.node.getBoundingClientRect().top);
+                    if (!candidates.length) {
+                        return { ok: false, reason: "Nao achei o campo de mensagem do WhatsApp Web." };
+                    }
+                    const composer = candidates[0].node;
+                    composer.focus();
+                    composer.click();
+                    return { ok: true };
+                });
+                if (focusedComposer.ok) {
+                    break;
                 }
-                const composer = candidates[0];
-                composer.focus();
-                composer.click();
-                return { ok: true };
-            });
+                await page.waitForTimeout(450);
+            }
             if (!focusedComposer.ok) {
                 return { sent: false, reason: String(focusedComposer.reason || "Nao achei o campo de mensagem do WhatsApp Web.") };
             }
@@ -527,6 +653,9 @@ export class WhatsAppBackgroundBrowser {
         }
     }
     async readVisibleConversation(limit) {
+        if (this.helperRuntime) {
+            return await this.helperRuntime.readVisibleConversation(limit);
+        }
         await this.ensureReady();
         const result = await this.withPage((page) => page.evaluate((maxMessages) => {
             function isVisible(element) {
@@ -569,6 +698,9 @@ export class WhatsAppBackgroundBrowser {
         };
     }
     async verifyLastMessage(expectedText) {
+        if (this.helperRuntime) {
+            return await this.helperRuntime.verifyLastMessage(expectedText);
+        }
         const chat = await this.readVisibleConversation(6);
         if (!chat.messages.length) {
             return {

package/dist/whatsapp_runtime_provider.js

@@ -0,0 +1,28 @@
+import process from "node:process";
+export const DEFAULT_WHATSAPP_RUNTIME_PROVIDER = process.platform === "darwin" ? "macos-helper" : "embedded-playwright";
+export function resolveWhatsAppRuntimeProviderKind(rawValue) {
+    const normalized = String(rawValue || "").trim().toLowerCase();
+    if (normalized === "macos-helper" || normalized === "macos_helper") {
+        return "macos-helper";
+    }
+    return DEFAULT_WHATSAPP_RUNTIME_PROVIDER;
+}
+export function getConfiguredWhatsAppRuntimeProvider() {
+    const rawEnvValue = process.env.OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER;
+    const source = String(rawEnvValue || "").trim() ? "env" : "default";
+    const kind = resolveWhatsAppRuntimeProviderKind(rawEnvValue);
+    if (kind === "macos-helper") {
+        return {
+            kind,
+            source,
+            supportsDocklessBackground: true,
+            description: "Provider nativo macOS com helper WKWebView rodando sem aparecer no Dock.",
+        };
+    }
+    return {
+        kind,
+        source,
+        supportsDocklessBackground: false,
+        description: "Provider embutido com Playwright/Chromium persistente para o WhatsApp Web.",
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leg3ndy/otto-bridge",
-  "version": "0.6.10",
+  "version": "0.7.2",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",