@leg3ndy/otto-bridge 0.5.12 → 0.6.0

package/README.md

@@ -33,7 +33,7 @@ Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./leg3ndy-otto-bridge-0.4.1.tgz
+npm install -g ./leg3ndy-otto-bridge-0.6.0.tgz
 ```
 
 ## Publicacao
@@ -102,6 +102,18 @@ O adapter `clawd-cursor` continua disponivel como override opcional:
 otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
 ```
 
+### WhatsApp Web em background
+
+Fluxo recomendado no `0.6.0`:
+
+```bash
+otto-bridge extensions --install whatsappweb
+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.
+
 ### Ver estado local
 
 ```bash

package/dist/executors/native_macos.js

@@ -6,6 +6,7 @@ import process from "node:process";
 import { JobCancelledError } from "./shared.js";
 import { loadManagedBridgeExtensionState, saveManagedBridgeExtensionState, } from "../extensions.js";
 import { postDeviceJson, uploadDeviceJobArtifact } from "../http.js";
+import { WHATSAPP_WEB_URL, WhatsAppBackgroundBrowser, } from "../whatsapp_background.js";
 const KNOWN_APPS = [
     { canonical: "Safari", patterns: [/\bsafari\b/i] },
     { canonical: "Google Chrome", patterns: [/\bgoogle chrome\b/i, /\bchrome\b/i] },
@@ -32,7 +33,17 @@ const KNOWN_SITES = [
     { label: "X", url: "https://x.com", patterns: [/\bx\.com\b/i, /\btwitter\b/i, /\bxis\b/i] },
 ];
 const WHATSAPP_WEB_EXTENSION_SLUG = "whatsappweb";
-const WHATSAPP_WEB_URL = "https://web.whatsapp.com";
+const FILE_SEARCH_SKIP_DIRS = new Set([
+    ".git",
+    "node_modules",
+    ".venv",
+    ".next",
+    "dist",
+    "build",
+    ".cache",
+    "Library",
+    ".Trash",
+]);
 const GENERIC_VISUAL_STOP_WORDS = new Set([
     "o",
     "a",
@@ -452,6 +463,14 @@ function humanizeUrl(url) {
         return normalized;
     }
 }
+function urlHostname(url) {
+    try {
+        return new URL(normalizeUrl(url)).hostname.replace(/^www\./i, "").toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
 function uniqueStrings(values) {
     const seen = new Set();
     const result = [];
@@ -485,6 +504,23 @@ function looksLikeAffirmativeVisualVerification(answer) {
         || normalized.includes("resultado selecionado")
         || normalized.includes("foi acionado"));
 }
+function isVisionUnavailableReason(reason) {
+    const normalized = normalizeText(reason || "");
+    if (!normalized) {
+        return false;
+    }
+    return (normalized === "empty_output"
+        || normalized === "no_choice"
+        || normalized === "invalid_json"
+        || normalized.startsWith("error:"));
+}
+function formatVisionUnavailableMessage(reason, fallback) {
+    const detail = String(reason || "").trim();
+    if (!detail) {
+        return fallback;
+    }
+    return `${fallback} Motivo: ${detail}.`;
+}
 function mimeTypeFromPath(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     if (ext === ".png")
@@ -933,6 +969,7 @@ export class NativeMacOSJobExecutor {
     lastActiveApp = null;
     lastVisualTargetDescription = null;
     lastVisualTargetApp = null;
+    whatsappBackgroundBrowser = null;
     constructor(bridgeConfig) {
         this.bridgeConfig = bridgeConfig;
     }
@@ -1073,8 +1110,13 @@ export class NativeMacOSJobExecutor {
                         });
                         if (artifact?.storage_path) {
                             artifacts.push(artifact);
-                            const answer = await this.analyzeUploadedArtifact(job.job_id, artifact.storage_path, "Leia o que esta visivel nesta pagina da web e resuma em portugues brasileiro o conteudo principal. Inclua titulos, chamadas e o que parecer mais importante na tela.", artifact.mime_type);
-                            page.text = answer || page.text;
+                            const analysis = await this.analyzeUploadedArtifactDetailed(job.job_id, artifact.storage_path, "Leia o que esta visivel nesta pagina da web e resuma em portugues brasileiro o conteudo principal. Inclua titulos, chamadas e o que parecer mais importante na tela.", artifact.mime_type);
+                            if (analysis.available !== false && analysis.answer) {
+                                page.text = analysis.answer;
+                            }
+                            else if (!page.text) {
+                                page.text = formatVisionUnavailableMessage(analysis.reason || "", "Nao consegui extrair texto util da pagina pelo modulo de visao.");
+                            }
                         }
                     }
                     resultPayload.page = page;
@@ -1201,6 +1243,10 @@ export class NativeMacOSJobExecutor {
                                 let validationReason = "";
                                 if (action.verification_prompt) {
                                     const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, action.verification_prompt, progressPercent, reporter, artifacts, "native_media_transport_result");
+                                    if (verification.unavailable) {
+                                        lastFailureReason = verification.reason;
+                                        break;
+                                    }
                                     validated = verification.ok;
                                     validationReason = verification.reason;
                                 }
@@ -1236,6 +1282,10 @@ export class NativeMacOSJobExecutor {
                                 let validationReason = "";
                                 if (action.verification_prompt) {
                                     const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, action.verification_prompt, progressPercent, reporter, artifacts, "dom_click_result");
+                                    if (verification.unavailable) {
+                                        lastFailureReason = verification.reason;
+                                        break;
+                                    }
                                     validated = verification.ok;
                                     validationReason = verification.reason;
                                 }
@@ -1275,6 +1325,10 @@ export class NativeMacOSJobExecutor {
                             let validationReason = "";
                             if (action.verification_prompt) {
                                 const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, action.verification_prompt, progressPercent, reporter, artifacts, "local_ocr_click_result");
+                                if (verification.unavailable) {
+                                    lastFailureReason = verification.reason;
+                                    break;
+                                }
                                 validated = verification.ok;
                                 validationReason = verification.reason;
                             }
@@ -1337,7 +1391,12 @@ export class NativeMacOSJobExecutor {
                         const originalHeight = Number(artifactMetadata.original_height || height || 0);
                         const location = await this.locateVisualTarget(job.job_id, artifact.storage_path, targetDescription, width, height, artifact.mime_type);
                         if (!location?.found || typeof location.x !== "number" || typeof location.y !== "number") {
-                            lastFailureReason = `Nao consegui localizar ${targetDescription} com confianca suficiente na tela.`;
+                            lastFailureReason = location?.reasoning
+                                ? `Nao consegui localizar ${targetDescription} com confianca suficiente na tela. ${location.reasoning}`
+                                : `Nao consegui localizar ${targetDescription} com confianca suficiente na tela.`;
+                            if (isVisionUnavailableReason(String(location?.reasoning || ""))) {
+                                break;
+                            }
                             continue;
                         }
                         await reporter.progress(progressPercent, `Clicando em ${targetDescription}`);
@@ -1352,6 +1411,10 @@ export class NativeMacOSJobExecutor {
                         };
                         if (action.verification_prompt) {
                             const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, action.verification_prompt, progressPercent, reporter, artifacts, "visual_click_result");
+                            if (verification.unavailable) {
+                                lastFailureReason = verification.reason;
+                                break;
+                            }
                             if (!verification.ok) {
                                 lastFailureReason = verification.reason || `Nao consegui validar visualmente se ${targetDescription} foi acionado.`;
                                 continue;
@@ -1418,6 +1481,7 @@ export class NativeMacOSJobExecutor {
             await reporter.completed(resultPayload);
         }
         finally {
+            await this.closeWhatsAppBackgroundBrowser();
             this.cancelledJobs.delete(job.job_id);
         }
     }
@@ -1438,6 +1502,15 @@ export class NativeMacOSJobExecutor {
         await this.focusApp(app);
     }
     async openUrl(url, app) {
+        if (app === "Safari") {
+            const reused = await this.tryReuseSafariTab(url);
+            if (!reused) {
+                await this.runCommand("open", ["-a", app, url]);
+            }
+            await this.focusApp(app);
+            this.lastActiveApp = app;
+            return;
+        }
         if (app) {
             await this.runCommand("open", ["-a", app, url]);
             await this.focusApp(app);
@@ -1446,6 +1519,50 @@ export class NativeMacOSJobExecutor {
         }
         await this.runCommand("open", [url]);
     }
+    async tryReuseSafariTab(url) {
+        const targetUrl = normalizeUrl(url);
+        const targetHost = urlHostname(targetUrl);
+        if (!targetHost) {
+            return false;
+        }
+        const script = `
+set targetHost to "${escapeAppleScript(targetHost)}"
+set targetUrl to "${escapeAppleScript(targetUrl)}"
+tell application "Safari"
+  if (count of windows) = 0 then return "NO_WINDOW"
+  set matchedWindow to missing value
+  set matchedTab to missing value
+  repeat with w in windows
+    repeat with t in tabs of w
+      try
+        set tabUrl to (URL of t) as text
+      on error
+        set tabUrl to ""
+      end try
+      if tabUrl is not "" and tabUrl contains targetHost then
+        set matchedWindow to w
+        set matchedTab to t
+        exit repeat
+      end if
+    end repeat
+    if matchedTab is not missing value then exit repeat
+  end repeat
+  if matchedTab is missing value then return "NO_MATCH"
+  set index of matchedWindow to 1
+  set current tab of matchedWindow to matchedTab
+  set URL of matchedTab to targetUrl
+  activate
+  return "REUSED"
+end tell
+`;
+        try {
+            const { stdout } = await this.runCommandCapture("osascript", ["-e", script]);
+            return String(stdout || "").trim() === "REUSED";
+        }
+        catch {
+            return false;
+        }
+    }
     async createNote(text, title) {
         const noteTitle = clipText((title || deriveNoteTitle(text)).trim() || "Nota Otto", 120);
         const noteBodyText = stripDuplicatedTitleFromText(text, noteTitle);
@@ -2010,6 +2127,27 @@ end repeat
             lastStatusCheckAt: new Date().toISOString(),
         }).catch(() => undefined);
     }
+    async getWhatsAppBackgroundBrowser() {
+        if (this.whatsappBackgroundBrowser) {
+            return this.whatsappBackgroundBrowser;
+        }
+        const availability = await WhatsAppBackgroundBrowser.checkAvailability();
+        if (!availability.ok) {
+            return null;
+        }
+        const browser = new WhatsAppBackgroundBrowser({ headless: true });
+        await browser.start();
+        this.whatsappBackgroundBrowser = browser;
+        return browser;
+    }
+    async closeWhatsAppBackgroundBrowser() {
+        const browser = this.whatsappBackgroundBrowser;
+        this.whatsappBackgroundBrowser = null;
+        if (!browser) {
+            return;
+        }
+        await browser.close().catch(() => undefined);
+    }
     async readWhatsAppWebSessionState() {
         return this.runSafariJsonScript(`
 function isVisible(element) {
@@ -2050,6 +2188,35 @@ return {
         if (!currentState || currentState.status === "installed_needs_setup") {
             throw new Error("WhatsApp Web ainda nao foi configurado neste Otto Bridge. Rode `otto-bridge extensions --setup whatsappweb` para abrir o QR code.");
         }
+        const backgroundBrowser = await this.getWhatsAppBackgroundBrowser().catch(() => null);
+        if (backgroundBrowser) {
+            try {
+                const state = await backgroundBrowser.getSessionState();
+                if (state.connected) {
+                    await this.syncWhatsAppExtensionState("connected", "Sessao local do WhatsApp Web pronta para uso no browser em background.");
+                    return;
+                }
+                const disconnectedStatus = currentState.status === "connected" || currentState.status === "session_expired"
+                    ? "session_expired"
+                    : "waiting_login";
+                await this.syncWhatsAppExtensionState(disconnectedStatus, state.qrVisible
+                    ? "QR code visivel no browser persistente. Escaneie com o celular para concluir o login."
+                    : "Browser persistente do WhatsApp Web aberto, mas a sessao ainda nao esta pronta.");
+                if (disconnectedStatus === "session_expired") {
+                    throw new Error("A sessao do WhatsApp Web expirou nesta maquina. Rode `otto-bridge extensions --setup whatsappweb` para fazer login de novo e depois `otto-bridge extensions --status whatsappweb`.");
+                }
+                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`.");
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                if (detail.includes("expirou")
+                    || detail.includes("ainda nao esta conectado")
+                    || detail.includes("ainda nao esta pronta")) {
+                    throw error;
+                }
+                await this.closeWhatsAppBackgroundBrowser();
+            }
+        }
         let sessionState = null;
         try {
             sessionState = await this.readWhatsAppWebSessionState();
@@ -2097,6 +2264,10 @@ return {
         await this.syncWhatsAppExtensionState("connected", "Sessao local do WhatsApp Web pronta para uso.");
     }
     async selectWhatsAppConversation(contact) {
+        const backgroundBrowser = await this.getWhatsAppBackgroundBrowser().catch(() => null);
+        if (backgroundBrowser) {
+            return backgroundBrowser.selectConversation(contact);
+        }
         const prepared = await this.runSafariJsonScript(`
 const query = String(__input?.contact || "");
 const normalize = (value) => String(value || "").normalize("NFD").replace(/[\\u0300-\\u036f]/g, "").toLowerCase().trim();
@@ -2199,6 +2370,11 @@ return { clicked: true };
         return Boolean(result?.clicked);
     }
     async sendWhatsAppMessage(text) {
+        const backgroundBrowser = await this.getWhatsAppBackgroundBrowser().catch(() => null);
+        if (backgroundBrowser) {
+            await backgroundBrowser.sendMessage(text);
+            return;
+        }
         const result = await this.runSafariJsonScript(`
 const value = String(__input?.text || "");
 function isVisible(element) {
@@ -2273,6 +2449,10 @@ return { sent: true };
         }
     }
     async readWhatsAppVisibleConversation(contact, limit) {
+        const backgroundBrowser = await this.getWhatsAppBackgroundBrowser().catch(() => null);
+        if (backgroundBrowser) {
+            return backgroundBrowser.readVisibleConversation(limit);
+        }
         const result = await this.runSafariJsonScript(`
 const maxMessages = Number(__input?.limit || 12);
 
@@ -2316,6 +2496,10 @@ return { messages: messages.slice(-maxMessages) };
         };
     }
     async verifyWhatsAppLastMessage(expectedText) {
+        const backgroundBrowser = await this.getWhatsAppBackgroundBrowser().catch(() => null);
+        if (backgroundBrowser) {
+            return backgroundBrowser.verifyLastMessage(expectedText);
+        }
         const chat = await this.readWhatsAppVisibleConversation("Contato", 6);
         if (!chat.messages.length) {
             return {
@@ -2363,16 +2547,37 @@ return { messages: messages.slice(-maxMessages) };
         });
         return response.artifact || null;
     }
-    async analyzeUploadedArtifact(jobId, storagePath, question, mimeType) {
+    async analyzeUploadedArtifactDetailed(jobId, storagePath, question, mimeType) {
         if (!this.bridgeConfig?.apiBaseUrl || !this.bridgeConfig?.deviceToken) {
-            return "";
+            return {
+                available: false,
+                answer: "",
+                reason: "bridge_api_unavailable",
+            };
         }
         const response = await postDeviceJson(this.bridgeConfig.apiBaseUrl, this.bridgeConfig.deviceToken, `/v1/devices/jobs/${encodeURIComponent(jobId)}/vision/analyze`, {
             storage_path: storagePath,
             question,
             mime_type: mimeType || "image/jpeg",
         });
-        return String(response.answer || "").trim();
+        const rawAnalysis = asRecord(response.analysis);
+        const answer = String(rawAnalysis.answer || response.answer || "").trim();
+        const reason = String(rawAnalysis.reason || "").trim();
+        const confidence = Number(rawAnalysis.confidence);
+        const available = rawAnalysis.available === false
+            ? false
+            : Boolean(answer);
+        return {
+            available,
+            answer,
+            reason,
+            confidence: Number.isFinite(confidence) ? confidence : undefined,
+            raw_output: asString(rawAnalysis.raw_output) || undefined,
+        };
+    }
+    async analyzeUploadedArtifact(jobId, storagePath, question, mimeType) {
+        const analysis = await this.analyzeUploadedArtifactDetailed(jobId, storagePath, question, mimeType);
+        return analysis.answer || "";
     }
     async validateVisualClickWithVision(jobId, targetDescription, verificationPrompt, progressPercent, reporter, artifacts, purpose) {
         await delay(1600);
@@ -2401,7 +2606,15 @@ return { messages: messages.slice(-maxMessages) };
             };
         }
         artifacts.push(afterClickArtifact);
-        const verificationAnswer = await this.analyzeUploadedArtifact(jobId, afterClickArtifact.storage_path, verificationPrompt, afterClickArtifact.mime_type);
+        const analysis = await this.analyzeUploadedArtifactDetailed(jobId, afterClickArtifact.storage_path, verificationPrompt, afterClickArtifact.mime_type);
+        if (analysis.available === false || !String(analysis.answer || "").trim()) {
+            return {
+                ok: false,
+                unavailable: true,
+                reason: formatVisionUnavailableMessage(analysis.reason || "", `A visão remota nao retornou leitura util para validar ${targetDescription}.`),
+            };
+        }
+        const verificationAnswer = String(analysis.answer || "").trim();
         if (!looksLikeAffirmativeVisualVerification(verificationAnswer)) {
             return {
                 ok: false,
@@ -3243,8 +3456,8 @@ if let output = String(data: data, encoding: .utf8) {
             resized,
         };
     }
-    async readLocalFile(filePath, maxChars = 1800) {
-        const resolved = expandUserPath(filePath);
+    async readLocalFile(filePath, maxChars = 4000) {
+        const resolved = await this.resolveReadableFilePath(filePath);
         const extension = path.extname(resolved).toLowerCase();
         if (TEXTUTIL_READABLE_EXTENSIONS.has(extension)) {
             const { stdout } = await this.runCommandCapture("textutil", [
@@ -3265,6 +3478,75 @@ if let output = String(data: data, encoding: .utf8) {
         const content = sanitizeTextForJsonTransport(raw.toString("utf8"));
         return clipTextPreview(content || "(arquivo vazio)", maxChars);
     }
+    async resolveReadableFilePath(filePath) {
+        const resolved = expandUserPath(filePath);
+        try {
+            await stat(resolved);
+            return resolved;
+        }
+        catch {
+            // Continue into heuristic search below.
+        }
+        const filename = path.basename(resolved).trim();
+        if (!filename || filename === "." || filename === path.sep) {
+            return resolved;
+        }
+        const homeDir = os.homedir();
+        const requestedDir = path.dirname(resolved);
+        const preferredRoots = uniqueStrings([
+            requestedDir && requestedDir !== homeDir ? requestedDir : null,
+            path.join(homeDir, "Downloads"),
+            path.join(homeDir, "Desktop"),
+            path.join(homeDir, "Documents"),
+            homeDir,
+        ]);
+        const found = await this.findFileByName(filename, preferredRoots);
+        return found || resolved;
+    }
+    async findFileByName(filename, roots) {
+        const target = filename.toLowerCase();
+        for (const root of roots) {
+            let rootStat;
+            try {
+                rootStat = await stat(root);
+            }
+            catch {
+                continue;
+            }
+            if (!rootStat.isDirectory()) {
+                continue;
+            }
+            const queue = [root];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (!current)
+                    continue;
+                let entries;
+                try {
+                    entries = await readdir(current, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const entry of entries) {
+                    const entryPath = path.join(current, entry.name);
+                    if (entry.isDirectory()) {
+                        if (!FILE_SEARCH_SKIP_DIRS.has(entry.name)) {
+                            queue.push(entryPath);
+                        }
+                        continue;
+                    }
+                    if (!entry.isFile()) {
+                        continue;
+                    }
+                    if (entry.name.toLowerCase() === target) {
+                        return entryPath;
+                    }
+                }
+            }
+        }
+        return null;
+    }
     async listLocalFiles(directoryPath, limit = 40) {
         const resolved = expandUserPath(directoryPath);
         const entries = await readdir(resolved, { withFileTypes: true });

package/dist/extensions.js

@@ -5,7 +5,7 @@ export const MANAGED_BRIDGE_EXTENSIONS = {
     whatsappweb: {
         displayName: "WhatsApp Web",
         setupUrl: "https://web.whatsapp.com",
-        sessionMode: "safari_managed_tab",
+        sessionMode: "background_browser_persistent_profile",
     },
 };
 export function isManagedBridgeExtensionSlug(value) {

package/dist/main.js

@@ -5,6 +5,7 @@ import { clearBridgeConfig, getBridgeConfigPath, loadBridgeConfig, normalizeInst
 import { buildInstalledManagedExtensionState, formatManagedBridgeExtensionStatus, getManagedBridgeExtensionDefinition, isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, removeManagedBridgeExtensionState, saveManagedBridgeExtensionState, } from "./extensions.js";
 import { pairDevice } from "./pairing.js";
 import { BridgeRuntime } from "./runtime.js";
+import { detectWhatsAppBackgroundStatus, runWhatsAppBackgroundSetup, } from "./whatsapp_background.js";
 import { BRIDGE_PACKAGE_NAME, BRIDGE_VERSION, DEFAULT_PAIR_TIMEOUT_SECONDS, DEFAULT_POLL_INTERVAL_MS, } from "./types.js";
 function parseArgs(argv) {
     const [maybeCommand, ...rest] = argv;
@@ -99,46 +100,6 @@ function runChildCommand(command, args) {
         });
     });
 }
-function runChildCommandCapture(command, args, options) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            stdio: "pipe",
-            env: process.env,
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout?.setEncoding("utf8");
-        child.stderr?.setEncoding("utf8");
-        child.stdout?.on("data", (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr?.on("data", (chunk) => {
-            stderr += String(chunk);
-        });
-        child.on("error", (error) => {
-            reject(error);
-        });
-        child.on("exit", (code) => {
-            if (code === 0) {
-                resolve({ stdout, stderr });
-                return;
-            }
-            const detail = stderr.trim() || stdout.trim();
-            reject(new Error(detail || `${command} exited with code ${code ?? "unknown"}`));
-        });
-        if (options?.stdin !== undefined) {
-            child.stdin?.write(options.stdin);
-        }
-        child.stdin?.end();
-    });
-}
-function escapeAppleScript(value) {
-    return value
-        .replace(/\\/g, "\\\\")
-        .replace(/"/g, '\\"')
-        .replace(/\r/g, "\\r")
-        .replace(/\n/g, "\\n");
-}
 async function openManagedExtensionSetup(slug) {
     const definition = getManagedBridgeExtensionDefinition(slug);
     if (process.platform !== "darwin") {
@@ -147,95 +108,7 @@ async function openManagedExtensionSetup(slug) {
     await runChildCommand("open", ["-a", "Safari", definition.setupUrl]);
 }
 async function detectManagedWhatsAppWebStatus() {
-    if (process.platform !== "darwin") {
-        return {
-            status: "installed_needs_setup",
-            notes: "Status automatico do WhatsApp Web ainda esta disponivel apenas no macOS.",
-        };
-    }
-    const jsCode = `
-(function(){
-  const qrVisible = Boolean(
-    document.querySelector('[data-testid="qrcode"], canvas[aria-label*="Scan"], canvas[aria-label*="scan"], div[data-ref] canvas')
-  );
-  const paneVisible = Boolean(document.querySelector('#pane-side, [data-testid="chat-list"]'));
-  const searchVisible = Boolean(document.querySelector('[data-testid="chat-list-search"] [contenteditable="true"], div[contenteditable="true"][role="textbox"]'));
-  const composerVisible = Boolean(document.querySelector('footer [contenteditable="true"], [data-testid="conversation-compose-box-input"]'));
-  return JSON.stringify({
-    ok: true,
-    title: document.title || '',
-    href: location.href || '',
-    qrVisible,
-    paneVisible,
-    searchVisible,
-    composerVisible
-  });
-})()
-`;
-    const script = `
-set targetUrlIncludes to "web.whatsapp.com"
-tell application "Safari"
-  if (count of windows) = 0 then return "{\\"ok\\":false,\\"reason\\":\\"not_open\\"}"
-  set targetTab to missing value
-  repeat with safariWindow in windows
-    repeat with safariTab in tabs of safariWindow
-      set tabUrl to ""
-      try
-        set tabUrl to URL of safariTab
-      end try
-      if tabUrl contains targetUrlIncludes then
-        set targetTab to safariTab
-        exit repeat
-      end if
-    end repeat
-    if targetTab is not missing value then exit repeat
-  end repeat
-  if targetTab is missing value then return "{\\"ok\\":false,\\"reason\\":\\"not_open\\"}"
-  set scriptResult to do JavaScript "${escapeAppleScript(jsCode)}" in targetTab
-end tell
-return scriptResult
-`;
-    try {
-        const { stdout } = await runChildCommandCapture("osascript", ["-e", script]);
-        const parsed = JSON.parse(stdout.trim() || "{}");
-        if (parsed.ok !== true) {
-            return {
-                status: "not_open",
-                notes: "Nenhuma aba do WhatsApp Web foi encontrada no Safari.",
-            };
-        }
-        const qrVisible = parsed.qrVisible === true;
-        const paneVisible = parsed.paneVisible === true;
-        const searchVisible = parsed.searchVisible === true;
-        const composerVisible = parsed.composerVisible === true;
-        const title = typeof parsed.title === "string" ? parsed.title : "";
-        if (paneVisible || searchVisible || composerVisible) {
-            return {
-                status: "connected",
-                notes: title ? `Sessao conectada em "${title}".` : "Sessao conectada.",
-            };
-        }
-        if (qrVisible) {
-            return {
-                status: "waiting_login",
-                notes: "QR code visivel. Escaneie com o celular para concluir o login.",
-            };
-        }
-        return {
-            status: "waiting_login",
-            notes: title ? `Aba aberta em "${title}", mas o login ainda nao foi confirmado.` : "Aba aberta, mas o login ainda nao foi confirmado.",
-        };
-    }
-    catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        if (detail.toLowerCase().includes("allow javascript from apple events")) {
-            return {
-                status: "waiting_login",
-                notes: "Ative 'Allow JavaScript from Apple Events' no Safari para o bridge verificar o status automaticamente.",
-            };
-        }
-        throw error;
-    }
+    return detectWhatsAppBackgroundStatus();
 }
 async function detectManagedExtensionStatus(slug, currentState) {
     if (slug === "whatsappweb") {
@@ -371,17 +244,35 @@ async function runExtensionsCommand(args) {
         if (!isManagedBridgeExtensionSlug(slug)) {
             throw new Error(`A extensao ${slug} nao possui setup interativo gerenciado no bridge.`);
         }
-        const definition = getManagedBridgeExtensionDefinition(slug);
         const currentState = await buildInstalledManagedExtensionState(slug);
-        await saveManagedBridgeExtensionState(slug, {
+        const baseState = {
             ...currentState,
             status: "waiting_login",
             lastSetupAt: new Date().toISOString(),
-            notes: `Setup iniciado para ${definition.displayName}. Escaneie o QR code no Safari e depois rode \`otto-bridge extensions --status ${slug}\`.`,
+        };
+        await saveManagedBridgeExtensionState(slug, {
+            ...baseState,
+            notes: `Setup iniciado para ${currentState.displayName}. Aguarde o login no browser persistente e depois rode \`otto-bridge extensions --status ${slug}\`.`,
         });
+        if (slug === "whatsappweb") {
+            const detected = await runWhatsAppBackgroundSetup({
+                log: (message) => console.log(`[otto-bridge] ${message}`),
+            });
+            await saveManagedBridgeExtensionState(slug, {
+                ...baseState,
+                status: detected.status,
+                notes: detected.notes,
+                lastStatusCheckAt: new Date().toISOString(),
+            });
+            console.log(`[otto-bridge] ${slug}: ${formatManagedBridgeExtensionStatus(detected.status)}`);
+            if (detected.notes) {
+                console.log(`[otto-bridge] ${detected.notes}`);
+            }
+            return;
+        }
+        const definition = getManagedBridgeExtensionDefinition(slug);
         await openManagedExtensionSetup(slug);
         console.log(`[otto-bridge] setup iniciado para ${definition.displayName}`);
-        console.log(`[otto-bridge] escaneie o QR code no Safari e depois rode: otto-bridge extensions --status ${slug}`);
         return;
     }
     if (statusValue) {

package/dist/runtime.js

@@ -3,6 +3,7 @@ import { ClawdCursorJobExecutor } from "./executors/clawd_cursor.js";
 import { MockJobExecutor } from "./executors/mock.js";
 import { NativeMacOSJobExecutor } from "./executors/native_macos.js";
 import { JobCancelledError } from "./executors/shared.js";
+import { isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, } from "./extensions.js";
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -78,6 +79,62 @@ export class BridgeRuntime {
         this.config = config;
         this.executor = executor ?? this.createDefaultExecutor(config);
     }
+    async buildHelloMetadata() {
+        const metadata = {
+            ...(this.config.metadata || {}),
+            installed_extensions: this.config.installedExtensions,
+        };
+        const managedExtensions = {};
+        const connectedMessageApps = new Set();
+        for (const rawSlug of this.config.installedExtensions) {
+            const slug = String(rawSlug || "").trim().toLowerCase();
+            if (!slug || !isManagedBridgeExtensionSlug(slug)) {
+                continue;
+            }
+            const state = await loadManagedBridgeExtensionState(slug);
+            if (!state) {
+                continue;
+            }
+            const app = slug === "whatsappweb" ? "whatsapp" : "";
+            const category = slug === "whatsappweb" ? "messaging" : "";
+            const connected = state.status === "connected";
+            managedExtensions[slug] = {
+                slug: state.slug,
+                display_name: state.displayName,
+                setup_url: state.setupUrl,
+                session_mode: state.sessionMode,
+                status: state.status,
+                installed_at: state.installedAt,
+                last_setup_at: state.lastSetupAt,
+                last_status_check_at: state.lastStatusCheckAt,
+                notes: state.notes,
+                category: category || undefined,
+                app: app || undefined,
+                connected,
+            };
+            if (connected && category === "messaging" && app) {
+                connectedMessageApps.add(app);
+            }
+        }
+        if (Object.keys(managedExtensions).length > 0) {
+            metadata.managed_extensions = managedExtensions;
+        }
+        if (connectedMessageApps.size > 0) {
+            metadata.connected_message_apps = Array.from(connectedMessageApps);
+        }
+        return metadata;
+    }
+    async sendHello(socket) {
+        const metadata = await this.buildHelloMetadata();
+        socket.send(JSON.stringify({
+            type: "device.hello",
+            device_id: this.config.deviceId,
+            device_name: this.config.deviceName,
+            bridge_version: this.config.bridgeVersion,
+            capabilities: this.config.capabilities,
+            metadata,
+        }));
+    }
     async start() {
         console.log(`[otto-bridge] runtime start device=${this.config.deviceId}`);
         while (true) {
@@ -112,17 +169,10 @@ export class BridgeRuntime {
         return await new Promise((resolve, reject) => {
             socket.addEventListener("open", () => {
                 console.log(`[otto-bridge] connected ws=${this.config.wsUrl}`);
-                socket.send(JSON.stringify({
-                    type: "device.hello",
-                    device_id: this.config.deviceId,
-                    device_name: this.config.deviceName,
-                    bridge_version: this.config.bridgeVersion,
-                    capabilities: this.config.capabilities,
-                    metadata: {
-                        ...(this.config.metadata || {}),
-                        installed_extensions: this.config.installedExtensions,
-                    },
-                }));
+                this.sendHello(socket).catch((error) => {
+                    const detail = error instanceof Error ? error.message : String(error);
+                    console.error(`[otto-bridge] hello metadata failed: ${detail}`);
+                });
                 heartbeatTimer = setInterval(() => {
                     if (socket.readyState === WebSocket.OPEN) {
                         socket.send(JSON.stringify({

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "0.5.12";
+export const BRIDGE_VERSION = "0.6.0";
 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

@@ -0,0 +1,496 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { getBridgeHomeDir } from "./config.js";
+export const WHATSAPP_WEB_URL = "https://web.whatsapp.com";
+const DEFAULT_SETUP_TIMEOUT_MS = 5 * 60 * 1000;
+function moduleDir() {
+    return path.dirname(fileURLToPath(import.meta.url));
+}
+function playwrightImportCandidates() {
+    const candidates = [
+        "playwright",
+        pathToFileURL(path.resolve(moduleDir(), "../../leg3ndy-ai-frontend/node_modules/playwright/index.mjs")).href,
+    ];
+    return Array.from(new Set(candidates));
+}
+async function loadPlaywrightModule() {
+    const errors = [];
+    for (const candidate of playwrightImportCandidates()) {
+        try {
+            const loaded = await import(candidate);
+            if (loaded?.chromium?.launchPersistentContext) {
+                return loaded;
+            }
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            errors.push(`${candidate}: ${detail}`);
+        }
+    }
+    throw new Error(`Playwright nao esta disponivel para o Otto Bridge. ${errors.length ? `Detalhes: ${errors.join(" | ")}` : ""}`.trim());
+}
+function normalizeText(value) {
+    return String(value || "")
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .trim();
+}
+export function getWhatsAppBrowserUserDataDir() {
+    return path.join(getBridgeHomeDir(), "extensions", "whatsappweb-profile");
+}
+async function ensureWhatsAppBrowserUserDataDir() {
+    await mkdir(getWhatsAppBrowserUserDataDir(), { recursive: true });
+}
+function sessionStateToStatus(state) {
+    if (state.connected) {
+        return {
+            status: "connected",
+            notes: state.title ? `Sessao conectada em "${state.title}".` : "Sessao conectada.",
+        };
+    }
+    if (state.qrVisible) {
+        return {
+            status: "waiting_login",
+            notes: "QR code visivel. Escaneie com o celular para concluir o login.",
+        };
+    }
+    return {
+        status: "waiting_login",
+        notes: state.title
+            ? `Janela aberta em "${state.title}", mas a sessao ainda nao foi autenticada.`
+            : "Janela aberta, mas a sessao ainda nao foi autenticada.",
+    };
+}
+export class WhatsAppBackgroundBrowser {
+    options;
+    context = null;
+    page = null;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    static async checkAvailability() {
+        try {
+            await loadPlaywrightModule();
+            return { ok: true };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                reason: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async start() {
+        if (this.context && this.page) {
+            return;
+        }
+        const playwright = await loadPlaywrightModule();
+        await ensureWhatsAppBrowserUserDataDir();
+        this.context = await playwright.chromium.launchPersistentContext(getWhatsAppBrowserUserDataDir(), {
+            headless: this.options.headless !== false,
+            viewport: { width: 1440, height: 960 },
+            locale: "pt-BR",
+            timezoneId: "America/Sao_Paulo",
+            args: [
+                "--disable-backgrounding-occluded-windows",
+                "--disable-renderer-backgrounding",
+                "--disable-background-timer-throttling",
+                "--disable-features=Translate,AcceptCHFrame,MediaRouter",
+            ],
+        });
+        const pages = this.context.pages();
+        this.page = pages[0] || await this.context.newPage();
+        await this.ensureWhatsAppPage();
+    }
+    async close() {
+        const current = this.context;
+        this.page = null;
+        this.context = null;
+        if (!current) {
+            return;
+        }
+        await current.close().catch(() => undefined);
+    }
+    async getSessionState() {
+        const state = await this.withPage(async (page) => {
+            await this.ensureWhatsAppPage();
+            return page.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 ensureReady() {
+        const state = await this.getSessionState();
+        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 browser em background.");
+    }
+    async waitForLogin(timeoutMs = DEFAULT_SETUP_TIMEOUT_MS) {
+        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 this.page?.waitForTimeout(1500);
+        }
+        return lastState || await this.getSessionState();
+    }
+    async selectConversation(contact) {
+        await this.ensureReady();
+        const prepared = await this.withPage((page) => page.evaluate((query) => {
+            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;
+            }
+            function focusAndReplaceContent(element, value) {
+                element.focus();
+                const selection = window.getSelection();
+                const range = document.createRange();
+                range.selectNodeContents(element);
+                selection?.removeAllRanges();
+                selection?.addRange(range);
+                document.execCommand("selectAll", false);
+                document.execCommand("delete", false);
+                document.execCommand("insertText", false, value);
+                if ((element.innerText || "").trim() !== value.trim()) {
+                    element.textContent = value;
+                }
+                element.dispatchEvent(new InputEvent("input", { bubbles: true, data: value, inputType: "insertText" }));
+            }
+            const candidates = Array.from(document.querySelectorAll('div[contenteditable="true"][role="textbox"], 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." };
+            }
+            focusAndReplaceContent(candidates[0].node, String(query || ""));
+            return { ok: true };
+        }, contact));
+        if (!prepared.ok) {
+            return false;
+        }
+        await this.page?.waitForTimeout(900);
+        const result = await this.withPage((page) => page.evaluate((query) => {
+            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, reason: "Nao achei uma conversa visivel com esse nome." };
+            }
+            const winner = titleNodes[0];
+            const target = winner.container instanceof HTMLElement ? winner.container : winner.node;
+            target.scrollIntoView({ block: "center", inline: "center", behavior: "auto" });
+            target.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true, view: window }));
+            target.dispatchEvent(new MouseEvent("mouseup", { bubbles: true, cancelable: true, view: window }));
+            target.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true, view: window }));
+            if (typeof target.click === "function") {
+                target.click();
+            }
+            return { clicked: true };
+        }, contact));
+        return result.clicked === true;
+    }
+    async sendMessage(text) {
+        await this.ensureReady();
+        const result = await this.withPage((page) => page.evaluate((value) => {
+            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;
+            }
+            function clearAndFillComposer(element, nextValue) {
+                element.focus();
+                if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+                    element.value = "";
+                    element.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "deleteContentBackward", data: null }));
+                    element.value = nextValue;
+                    element.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: nextValue }));
+                    return;
+                }
+                const selection = window.getSelection();
+                const range = document.createRange();
+                range.selectNodeContents(element);
+                selection?.removeAllRanges();
+                selection?.addRange(range);
+                document.execCommand("selectAll", false);
+                document.execCommand("delete", false);
+                document.execCommand("insertText", false, nextValue);
+                if ((element.innerText || "").trim() !== nextValue.trim()) {
+                    element.textContent = 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);
+            if (!candidates.length) {
+                return { sent: false, reason: "Nao achei o campo de mensagem do WhatsApp Web." };
+            }
+            const composer = candidates[0];
+            clearAndFillComposer(composer, String(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" });
+                sendButton.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true, view: window }));
+                sendButton.dispatchEvent(new MouseEvent("mouseup", { bubbles: true, cancelable: true, view: window }));
+                sendButton.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true, view: window }));
+                if (typeof sendButton.click === "function") {
+                    sendButton.click();
+                }
+                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 };
+        }, text));
+        if (!result.sent) {
+            throw new Error(String(result.reason || "Nao consegui enviar a mensagem no WhatsApp Web."));
+        }
+    }
+    async readVisibleConversation(limit) {
+        await this.ensureReady();
+        const result = await this.withPage((page) => page.evaluate((maxMessages) => {
+            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(-Math.max(1, Number(maxMessages || 12))) };
+        }, limit));
+        const rawMessages = Array.isArray(result.messages)
+            ? result.messages
+            : [];
+        const messages = rawMessages
+            .map((item) => ({
+            author: clipText(String(item.author || "Contato"), 80),
+            text: clipText(String(item.text || ""), 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 visualmente a mensagem enviada no WhatsApp.",
+            };
+        }
+        return { ok: true, reason: "" };
+    }
+    async ensureWhatsAppPage() {
+        const page = this.page;
+        if (!page) {
+            return;
+        }
+        await page.goto(WHATSAPP_WEB_URL, {
+            waitUntil: "domcontentloaded",
+            timeout: 90_000,
+        }).catch(() => undefined);
+        await page.waitForTimeout(1200);
+    }
+    async withPage(handler) {
+        await this.start();
+        if (!this.page) {
+            throw new Error("WhatsApp background browser nao conseguiu abrir a pagina.");
+        }
+        return handler(this.page);
+    }
+}
+function clipText(text, maxLength) {
+    const value = String(text || "").trim();
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+export async function detectWhatsAppBackgroundStatus() {
+    const availability = await WhatsAppBackgroundBrowser.checkAvailability();
+    if (!availability.ok) {
+        return {
+            status: "not_open",
+            notes: availability.reason || "Playwright nao esta disponivel para verificar o WhatsApp Web em background.",
+        };
+    }
+    const browser = new WhatsAppBackgroundBrowser({ headless: true });
+    try {
+        const state = await browser.getSessionState();
+        return sessionStateToStatus(state);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+            status: "not_open",
+            notes: detail || "Nao consegui abrir o browser em background para verificar o WhatsApp Web.",
+        };
+    }
+    finally {
+        await browser.close();
+    }
+}
+export async function runWhatsAppBackgroundSetup(options) {
+    const browser = new WhatsAppBackgroundBrowser({ headless: false });
+    const log = options?.log;
+    try {
+        await browser.start();
+        const initialState = await browser.getSessionState();
+        if (initialState.connected) {
+            return {
+                status: "connected",
+                notes: "Sessao ja conectada no browser persistente do WhatsApp Web.",
+            };
+        }
+        log?.("Janela de setup do WhatsApp Web aberta no browser persistente do Otto Bridge.");
+        log?.("Escaneie o QR code e aguarde a sincronizacao da conversa.");
+        const finalState = await browser.waitForLogin(options?.timeoutMs || DEFAULT_SETUP_TIMEOUT_MS);
+        const detected = sessionStateToStatus(finalState);
+        if (detected.status !== "connected") {
+            return {
+                status: "waiting_login",
+                notes: "O setup abriu o browser persistente, mas o login ainda nao foi concluido.",
+            };
+        }
+        return detected;
+    }
+    finally {
+        await browser.close();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leg3ndy/otto-bridge",
-  "version": "0.5.12",
+  "version": "0.6.0",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",
@@ -48,6 +48,9 @@
   "engines": {
     "node": ">=24"
   },
+  "optionalDependencies": {
+    "playwright": "^1.58.2"
+  },
   "devDependencies": {
     "@types/node": "^25.3.0",
     "typescript": "^5.9.3"