@leg3ndy/otto-bridge 0.5.9 → 0.5.14

package/dist/executors/native_macos.js

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { JobCancelledError } from "./shared.js";
+import { loadManagedBridgeExtensionState, saveManagedBridgeExtensionState, } from "../extensions.js";
 import { postDeviceJson, uploadDeviceJobArtifact } from "../http.js";
 const KNOWN_APPS = [
     { canonical: "Safari", patterns: [/\bsafari\b/i] },
@@ -30,6 +31,19 @@ const KNOWN_SITES = [
     { label: "WhatsApp Web", url: "https://web.whatsapp.com", patterns: [/\bwhatsapp\b/i] },
     { 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",
@@ -449,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 = [];
@@ -980,6 +1002,17 @@ export class NativeMacOSJobExecutor {
                 if (action.type === "press_shortcut") {
                     await reporter.progress(progressPercent, `Enviando atalho ${action.shortcut}`);
                     await this.pressShortcut(action.shortcut);
+                    if (action.shortcut.startsWith("media_")) {
+                        const mediaSummaryMap = {
+                            media_next: "Acionei o comando de próxima mídia no macOS.",
+                            media_previous: "Acionei o comando de mídia anterior no macOS.",
+                            media_pause: "Acionei o comando de pausar mídia no macOS.",
+                            media_resume: "Acionei o comando de retomar mídia no macOS.",
+                            media_play: "Acionei o comando de reproduzir mídia no macOS.",
+                            media_play_pause: "Acionei o comando de play/pause de mídia no macOS.",
+                        };
+                        completionNotes.push(mediaSummaryMap[action.shortcut] || `Acionei ${action.shortcut} no macOS.`);
+                    }
                     continue;
                 }
                 if (action.type === "create_note") {
@@ -1123,17 +1156,13 @@ export class NativeMacOSJobExecutor {
                 }
                 if (action.type === "whatsapp_send_message") {
                     await reporter.progress(progressPercent, `Abrindo a conversa do WhatsApp com ${action.contact}`);
-                    await this.focusApp("Safari");
                     await this.ensureWhatsAppWebReady();
                     const selected = await this.selectWhatsAppConversation(action.contact);
                     if (!selected) {
                         throw new Error(`Nao consegui localizar a conversa do WhatsApp com ${action.contact}.`);
                     }
-                    await reporter.progress(progressPercent, `Digitando a mensagem para ${action.contact} no WhatsApp`);
-                    await this.focusWhatsAppComposer();
-                    await this.typeText(action.text);
-                    await delay(250);
-                    await this.pressShortcut("return");
+                    await reporter.progress(progressPercent, `Enviando a mensagem para ${action.contact} no WhatsApp`);
+                    await this.sendWhatsAppMessage(action.text);
                     await delay(900);
                     const verification = await this.verifyWhatsAppLastMessage(action.text);
                     if (!verification.ok) {
@@ -1149,7 +1178,6 @@ export class NativeMacOSJobExecutor {
                 }
                 if (action.type === "whatsapp_read_chat") {
                     await reporter.progress(progressPercent, `Abrindo a conversa do WhatsApp com ${action.contact}`);
-                    await this.focusApp("Safari");
                     await this.ensureWhatsAppWebReady();
                     const selected = await this.selectWhatsAppConversation(action.contact);
                     if (!selected) {
@@ -1429,6 +1457,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);
@@ -1437,6 +1474,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);
@@ -1978,11 +2059,114 @@ end repeat
 `;
         await this.runCommand("osascript", ["-e", script]);
     }
+    hasInstalledBridgeExtension(slug) {
+        return Array.isArray(this.bridgeConfig?.installedExtensions)
+            ? this.bridgeConfig?.installedExtensions.includes(slug)
+            : false;
+    }
+    getWhatsAppWebScriptOptions(activate = false) {
+        return {
+            targetUrlIncludes: "web.whatsapp.com",
+            activate,
+        };
+    }
+    async syncWhatsAppExtensionState(status, notes) {
+        const current = await loadManagedBridgeExtensionState(WHATSAPP_WEB_EXTENSION_SLUG).catch(() => null);
+        if (!current) {
+            return;
+        }
+        await saveManagedBridgeExtensionState(WHATSAPP_WEB_EXTENSION_SLUG, {
+            ...current,
+            status,
+            notes,
+            lastStatusCheckAt: new Date().toISOString(),
+        }).catch(() => undefined);
+    }
+    async readWhatsAppWebSessionState() {
+        return this.runSafariJsonScript(`
+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;
+}
+
+return {
+  title: document.title || "",
+  url: location.href || "",
+  qrVisible: Array.from(document.querySelectorAll('[data-testid="qrcode"], canvas[aria-label*="Scan"], canvas[aria-label*="scan"], div[data-ref] canvas'))
+    .some((node) => node instanceof HTMLElement ? isVisible(node) : true),
+  paneVisible: Array.from(document.querySelectorAll('#pane-side, [data-testid="chat-list"]'))
+    .some((node) => node instanceof HTMLElement && isVisible(node)),
+  searchVisible: Array.from(document.querySelectorAll('[data-testid="chat-list-search"] [contenteditable="true"], div[contenteditable="true"][role="textbox"]'))
+    .some((node) => node instanceof HTMLElement && isVisible(node)),
+  composerVisible: Array.from(document.querySelectorAll('footer [contenteditable="true"], [data-testid="conversation-compose-box-input"]'))
+    .some((node) => node instanceof HTMLElement && isVisible(node)),
+};
+      `, {}, this.getWhatsAppWebScriptOptions(false)).then((result) => ({
+            title: asString(result.title) || "",
+            url: asString(result.url) || "",
+            qrVisible: result.qrVisible === true,
+            paneVisible: result.paneVisible === true,
+            searchVisible: result.searchVisible === true,
+            composerVisible: result.composerVisible === true,
+        }));
+    }
     async ensureWhatsAppWebReady() {
-        const page = await this.readFrontmostPage("Safari");
-        if (!normalizeComparableUrl(page.url || "").includes("web.whatsapp.com")) {
-            throw new Error("O Safari nao esta aberto no WhatsApp Web.");
+        if (!this.hasInstalledBridgeExtension(WHATSAPP_WEB_EXTENSION_SLUG)) {
+            throw new Error("WhatsApp Web nao esta instalado neste Otto Bridge. Rode `otto-bridge extensions --install whatsappweb` e depois `otto-bridge extensions --setup whatsappweb`.");
+        }
+        const currentState = await loadManagedBridgeExtensionState(WHATSAPP_WEB_EXTENSION_SLUG).catch(() => null);
+        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.");
+        }
+        let sessionState = null;
+        try {
+            sessionState = await this.readWhatsAppWebSessionState();
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            if (detail.toLowerCase().includes("aba correspondente")) {
+                await this.openUrl(WHATSAPP_WEB_URL, "Safari");
+                await delay(1400);
+                try {
+                    sessionState = await this.readWhatsAppWebSessionState();
+                }
+                catch {
+                    sessionState = null;
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+        if (!sessionState) {
+            const disconnectedStatus = currentState.status === "connected" || currentState.status === "session_expired"
+                ? "session_expired"
+                : "not_open";
+            await this.syncWhatsAppExtensionState(disconnectedStatus, disconnectedStatus === "session_expired"
+                ? "A sessao do WhatsApp Web expirou ou foi fechada. Rode `otto-bridge extensions --setup whatsappweb` para abrir o login novamente."
+                : "Nao consegui localizar uma aba do WhatsApp Web no Safari.");
+            throw new Error("Nao consegui localizar uma aba do WhatsApp Web no Safari. Rode `otto-bridge extensions --setup whatsappweb` se precisar reabrir a sessao.");
+        }
+        const loggedIn = sessionState.paneVisible || sessionState.searchVisible || sessionState.composerVisible;
+        if (!loggedIn) {
+            const disconnectedStatus = currentState.status === "connected" || currentState.status === "session_expired"
+                ? "session_expired"
+                : "waiting_login";
+            await this.syncWhatsAppExtensionState(disconnectedStatus, disconnectedStatus === "session_expired"
+                ? "A sessao do WhatsApp Web expirou. Rode `otto-bridge extensions --setup whatsappweb` para abrir o QR code novamente."
+                : sessionState.qrVisible
+                    ? "QR code visivel. Escaneie com o celular para concluir o login."
+                    : "Sessao do WhatsApp Web aberta, mas ainda sem chat disponivel.");
+            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`.");
         }
+        await this.syncWhatsAppExtensionState("connected", "Sessao local do WhatsApp Web pronta para uso.");
     }
     async selectWhatsAppConversation(contact) {
         const prepared = await this.runSafariJsonScript(`
@@ -2034,7 +2218,7 @@ if (!candidates.length) {
 
 focusAndReplaceContent(candidates[0].element, query);
 return { ok: true };
-      `, { contact });
+      `, { contact }, this.getWhatsAppWebScriptOptions(false));
         if (!prepared?.ok) {
             return false;
         }
@@ -2083,11 +2267,12 @@ if (typeof target.click === "function") {
   target.click();
 }
 return { clicked: true };
-      `, { contact });
+      `, { contact }, this.getWhatsAppWebScriptOptions(false));
         return Boolean(result?.clicked);
     }
-    async focusWhatsAppComposer() {
+    async sendWhatsAppMessage(text) {
         const result = await this.runSafariJsonScript(`
+const value = String(__input?.text || "");
 function isVisible(element) {
   if (!(element instanceof HTMLElement)) return false;
   const rect = element.getBoundingClientRect();
@@ -2097,22 +2282,66 @@ function isVisible(element) {
   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"]'))
+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 { focused: false, reason: "Nao achei o campo de mensagem do WhatsApp Web." };
+  return { sent: false, reason: "Nao achei o campo de mensagem do WhatsApp Web." };
 }
 
 const composer = candidates[0];
-composer.focus();
+clearAndFillComposer(composer, value);
 composer.click();
-return { focused: true };
-      `);
-        if (!result?.focused) {
-            throw new Error(result?.reason || "Nao consegui focar o campo de mensagem do WhatsApp Web.");
+
+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 }, this.getWhatsAppWebScriptOptions(false));
+        if (!result?.sent) {
+            throw new Error(result?.reason || "Nao consegui enviar a mensagem no WhatsApp Web.");
         }
     }
     async readWhatsAppVisibleConversation(contact, limit) {
@@ -2142,7 +2371,7 @@ const messages = containers.map((node) => {
 }).filter((item) => item.text);
 
 return { messages: messages.slice(-maxMessages) };
-      `, { contact, limit });
+      `, { contact, limit }, this.getWhatsAppWebScriptOptions(false));
         const messages = Array.isArray(result?.messages)
             ? result.messages
                 .map((item) => ({
@@ -2256,7 +2485,7 @@ return { messages: messages.slice(-maxMessages) };
             reason: verificationAnswer,
         };
     }
-    async runSafariJsonScript(scriptBody, input) {
+    async runSafariJsonScript(scriptBody, input, options) {
         const wrappedScript = `
 (function(){
   const __input = ${JSON.stringify(input || null)};
@@ -2273,12 +2502,42 @@ ${scriptBody}
   }
 })()
 `;
+        const targetUrlIncludes = String(options?.targetUrlIncludes || "").trim();
+        const shouldActivate = options?.activate !== false;
         const script = `
+set targetUrlIncludes to "${escapeAppleScript(targetUrlIncludes)}"
+set shouldActivate to ${shouldActivate ? "true" : "false"}
 tell application "Safari"
-  activate
   if (count of windows) = 0 then error "Safari nao possui janelas abertas."
+  if shouldActivate then activate
+  set targetWindow to missing value
+  set targetTab to missing value
+  if targetUrlIncludes is not "" then
+    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 targetWindow to safariWindow
+          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 error "Safari nao possui aba correspondente a " & targetUrlIncludes
+  else
+    set targetWindow to front window
+    set targetTab to current tab of front window
+  end if
+  if shouldActivate and targetWindow is not missing value then
+    set current tab of targetWindow to targetTab
+    set index of targetWindow to 1
+  end if
   delay 0.2
-  set scriptResult to do JavaScript "${escapeAppleScript(wrappedScript)}" in current tab of front window
+  set scriptResult to do JavaScript "${escapeAppleScript(wrappedScript)}" in targetTab
 end tell
 return scriptResult
 `;
@@ -2673,7 +2932,8 @@ tell application "Safari"
   activate
   if (count of windows) = 0 then error "Safari nao possui janelas abertas."
   delay 1
-  set pageJson to do JavaScript "(function(){const title=document.title||''; const url=location.href||''; const text=((document.body&&document.body.innerText)||'').trim().slice(0, 12000); const playerButton=document.querySelector('ytmusic-player-bar #play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button#play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button.play-pause-button'); const playerTitle=(Array.from(document.querySelectorAll('ytmusic-player-bar .title, ytmusic-player-bar .content-info-wrapper .title, ytmusic-player-bar [slot=\"title\"]')).map((node)=>((node&&node.textContent)||'').trim()).find(Boolean))||''; const playerState=(playerButton&&((playerButton.getAttribute('title')||playerButton.getAttribute('aria-label')||playerButton.textContent)||'').trim())||''; return JSON.stringify({title:title,url:url,text:text,playerTitle:playerTitle,playerState:playerState});})();" in current tab of front window
+  set jsCode to "(function(){const title=document.title||'';const url=location.href||'';const text=((document.body&&document.body.innerText)||'').trim().slice(0,12000);const playerButton=document.querySelector('ytmusic-player-bar #play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button#play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button.play-pause-button');const playerTitle=(Array.from(document.querySelectorAll('ytmusic-player-bar .title, ytmusic-player-bar .content-info-wrapper .title, ytmusic-player-bar [slot=title]')).map((node)=>((node&&node.textContent)||'').trim()).find(Boolean))||'';const playerState=(playerButton&&((playerButton.getAttribute('title')||playerButton.getAttribute('aria-label')||playerButton.textContent)||'').trim())||'';return JSON.stringify({title,url,text,playerTitle,playerState});})();"
+  set pageJson to do JavaScript jsCode in current tab of front window
 end tell
 return pageJson
 `;
@@ -3055,8 +3315,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", [
@@ -3077,6 +3337,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 });
@@ -3174,7 +3503,15 @@ if let output = String(data: data, encoding: .utf8) {
             return `${action.app} ficou em foco no macOS`;
         }
         if (action.type === "press_shortcut") {
-            return `Atalho ${action.shortcut} executado no macOS`;
+            const mediaSummaryMap = {
+                media_next: "Comando de próxima mídia executado no macOS",
+                media_previous: "Comando de mídia anterior executado no macOS",
+                media_pause: "Comando de pausar mídia executado no macOS",
+                media_resume: "Comando de retomar mídia executado no macOS",
+                media_play: "Comando de reproduzir mídia executado no macOS",
+                media_play_pause: "Comando de play/pause de mídia executado no macOS",
+            };
+            return mediaSummaryMap[action.shortcut] || `Atalho ${action.shortcut} executado no macOS`;
         }
         if (action.type === "create_note") {
             return `Nota criada no Notes: ${action.title || deriveNoteTitle(action.text)}`;

package/dist/extensions.js

@@ -0,0 +1,79 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getBridgeHomeDir } from "./config.js";
+export const MANAGED_BRIDGE_EXTENSIONS = {
+    whatsappweb: {
+        displayName: "WhatsApp Web",
+        setupUrl: "https://web.whatsapp.com",
+        sessionMode: "safari_managed_tab",
+    },
+};
+export function isManagedBridgeExtensionSlug(value) {
+    return Object.prototype.hasOwnProperty.call(MANAGED_BRIDGE_EXTENSIONS, value);
+}
+export function getManagedBridgeExtensionDefinition(slug) {
+    return MANAGED_BRIDGE_EXTENSIONS[slug];
+}
+export function getBridgeExtensionsDir() {
+    return path.join(getBridgeHomeDir(), "extensions");
+}
+function getManagedExtensionStatePath(slug) {
+    return path.join(getBridgeExtensionsDir(), `${slug}.json`);
+}
+export async function ensureBridgeExtensionsDir() {
+    await mkdir(getBridgeExtensionsDir(), { recursive: true });
+}
+export async function loadManagedBridgeExtensionState(slug) {
+    try {
+        const raw = await readFile(getManagedExtensionStatePath(slug), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        if (parsed.slug !== slug) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveManagedBridgeExtensionState(slug, state) {
+    await ensureBridgeExtensionsDir();
+    await writeFile(getManagedExtensionStatePath(slug), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+export async function removeManagedBridgeExtensionState(slug) {
+    await rm(getManagedExtensionStatePath(slug), { force: true });
+}
+export async function buildInstalledManagedExtensionState(slug) {
+    const definition = getManagedBridgeExtensionDefinition(slug);
+    const existing = await loadManagedBridgeExtensionState(slug);
+    return {
+        slug,
+        displayName: definition.displayName,
+        setupUrl: definition.setupUrl,
+        sessionMode: definition.sessionMode,
+        status: existing?.status || "installed_needs_setup",
+        installedAt: existing?.installedAt || new Date().toISOString(),
+        lastSetupAt: existing?.lastSetupAt,
+        lastStatusCheckAt: existing?.lastStatusCheckAt,
+        notes: existing?.notes,
+    };
+}
+export function formatManagedBridgeExtensionStatus(status) {
+    switch (status) {
+        case "installed_needs_setup":
+            return "instalada, falta setup";
+        case "waiting_login":
+            return "aguardando login";
+        case "connected":
+            return "conectada";
+        case "session_expired":
+            return "sessao expirada";
+        case "not_open":
+            return "instalada, aba nao aberta";
+        default:
+            return status;
+    }
+}

package/dist/main.js

@@ -2,6 +2,7 @@
 import { spawn } from "node:child_process";
 import process from "node:process";
 import { clearBridgeConfig, getBridgeConfigPath, loadBridgeConfig, normalizeInstalledExtensions, resolveApiBaseUrl, resolveExecutorConfig, saveBridgeConfig, } from "./config.js";
+import { buildInstalledManagedExtensionState, formatManagedBridgeExtensionStatus, getManagedBridgeExtensionDefinition, isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, removeManagedBridgeExtensionState, saveManagedBridgeExtensionState, } from "./extensions.js";
 import { pairDevice } from "./pairing.js";
 import { BridgeRuntime } from "./runtime.js";
 import { BRIDGE_PACKAGE_NAME, BRIDGE_VERSION, DEFAULT_PAIR_TIMEOUT_SECONDS, DEFAULT_POLL_INTERVAL_MS, } from "./types.js";
@@ -58,6 +59,8 @@ function printUsage() {
   otto-bridge status
   otto-bridge extensions --list
   otto-bridge extensions --install github
+  otto-bridge extensions --setup whatsappweb
+  otto-bridge extensions --status whatsappweb
   otto-bridge extensions --uninstall github
   otto-bridge version
   otto-bridge update [--tag latest|next] [--dry-run]
@@ -66,7 +69,9 @@ function printUsage() {
 Examples:
   otto-bridge pair --api https://api.leg3ndy.com.br --code ABC123
   otto-bridge run
-  otto-bridge extensions --install github
+  otto-bridge extensions --install whatsappweb
+  otto-bridge extensions --setup whatsappweb
+  otto-bridge extensions --status whatsappweb
   otto-bridge extensions --list
   otto-bridge version
   otto-bridge update
@@ -94,6 +99,162 @@ 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") {
+        throw new Error(`${definition.displayName} setup automatico esta disponivel apenas no macOS no momento.`);
+    }
+    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;
+    }
+}
+async function detectManagedExtensionStatus(slug, currentState) {
+    if (slug === "whatsappweb") {
+        const detected = await detectManagedWhatsAppWebStatus();
+        const shouldMarkExpired = (detected.status === "waiting_login"
+            && (currentState?.status === "connected" || currentState?.status === "session_expired"));
+        if (!shouldMarkExpired) {
+            return detected;
+        }
+        return {
+            status: "session_expired",
+            notes: "A sessao do WhatsApp Web expirou. Rode `otto-bridge extensions --setup whatsappweb` para abrir o QR code novamente.",
+        };
+    }
+    return {
+        status: "installed_needs_setup",
+        notes: "Esta extensao gerenciada ainda nao possui verificador automatico de status.",
+    };
+}
 async function runPairCommand(args) {
     const code = option(args, "code");
     if (!code) {
@@ -153,14 +314,25 @@ async function runStatusCommand() {
 async function runExtensionsCommand(args) {
     const config = await loadRequiredBridgeConfig();
     const installValue = option(args, "install");
+    const setupValue = option(args, "setup");
+    const statusValue = option(args, "status");
     const uninstallValue = option(args, "uninstall");
-    if (installValue && uninstallValue) {
-        throw new Error("Use apenas uma acao por vez: --install ou --uninstall.");
+    const wantsList = args.options.has("list");
+    const requestedActions = [
+        installValue ? "install" : null,
+        setupValue ? "setup" : null,
+        statusValue ? "status" : null,
+        uninstallValue ? "uninstall" : null,
+        wantsList ? "list" : null,
+    ].filter(Boolean);
+    if (requestedActions.length > 1) {
+        throw new Error("Use apenas uma acao por vez: --install, --setup, --status, --uninstall ou --list.");
     }
     if (installValue) {
+        const installSlugs = normalizeInstalledExtensions(installValue.split(","));
         const nextExtensions = normalizeInstalledExtensions([
             ...config.installedExtensions,
-            ...installValue.split(","),
+            ...installSlugs,
         ]);
         const added = nextExtensions.filter((item) => !config.installedExtensions.includes(item));
         if (!added.length) {
@@ -171,10 +343,74 @@ async function runExtensionsCommand(args) {
             ...config,
             installedExtensions: nextExtensions,
         });
+        for (const extension of added) {
+            if (!isManagedBridgeExtensionSlug(extension)) {
+                continue;
+            }
+            const state = await buildInstalledManagedExtensionState(extension);
+            await saveManagedBridgeExtensionState(extension, state);
+        }
         console.log(`[otto-bridge] extensoes instaladas: ${added.join(", ")}`);
+        for (const extension of added) {
+            if (!isManagedBridgeExtensionSlug(extension)) {
+                continue;
+            }
+            console.log(`[otto-bridge] proximo passo para ${extension}: otto-bridge extensions --setup ${extension}`);
+        }
         console.log("[otto-bridge] rode `otto-bridge run` novamente se quiser sincronizar agora com a web");
         return;
     }
+    if (setupValue) {
+        const slug = normalizeInstalledExtensions([setupValue])[0];
+        if (!slug) {
+            throw new Error("Informe uma extensao valida em --setup <slug>.");
+        }
+        if (!config.installedExtensions.includes(slug)) {
+            throw new Error(`A extensao ${slug} nao esta instalada. Rode \`otto-bridge extensions --install ${slug}\` primeiro.`);
+        }
+        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, {
+            ...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 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) {
+        const slug = normalizeInstalledExtensions([statusValue])[0];
+        if (!slug) {
+            throw new Error("Informe uma extensao valida em --status <slug>.");
+        }
+        if (!config.installedExtensions.includes(slug)) {
+            throw new Error(`A extensao ${slug} nao esta instalada neste bridge.`);
+        }
+        if (!isManagedBridgeExtensionSlug(slug)) {
+            console.log(`[otto-bridge] ${slug}: instalada (sem status gerenciado)`);
+            return;
+        }
+        const currentState = await buildInstalledManagedExtensionState(slug);
+        const detected = await detectManagedExtensionStatus(slug, currentState);
+        const nextState = {
+            ...currentState,
+            status: detected.status,
+            lastStatusCheckAt: new Date().toISOString(),
+            notes: detected.notes || currentState.notes,
+        };
+        await saveManagedBridgeExtensionState(slug, nextState);
+        console.log(`[otto-bridge] ${slug}: ${formatManagedBridgeExtensionStatus(nextState.status)}`);
+        if (nextState.notes) {
+            console.log(`[otto-bridge] ${nextState.notes}`);
+        }
+        return;
+    }
     if (uninstallValue) {
         const removeSet = new Set(normalizeInstalledExtensions(uninstallValue.split(",")));
         const nextExtensions = config.installedExtensions.filter((item) => !removeSet.has(item));
@@ -187,6 +423,11 @@ async function runExtensionsCommand(args) {
             ...config,
             installedExtensions: nextExtensions,
         });
+        for (const extension of removed) {
+            if (isManagedBridgeExtensionSlug(extension)) {
+                await removeManagedBridgeExtensionState(extension);
+            }
+        }
         console.log(`[otto-bridge] extensoes removidas: ${removed.join(", ")}`);
         console.log("[otto-bridge] rode `otto-bridge run` novamente se quiser sincronizar agora com a web");
         return;
@@ -197,7 +438,13 @@ async function runExtensionsCommand(args) {
     }
     console.log("[otto-bridge] extensoes instaladas:");
     for (const extension of config.installedExtensions) {
-        console.log(`- ${extension}`);
+        if (!isManagedBridgeExtensionSlug(extension)) {
+            console.log(`- ${extension}`);
+            continue;
+        }
+        const state = await loadManagedBridgeExtensionState(extension);
+        const suffix = state ? ` (${formatManagedBridgeExtensionStatus(state.status)})` : "";
+        console.log(`- ${extension}${suffix}`);
     }
 }
 async function runUnpairCommand() {

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "0.5.9";
+export const BRIDGE_VERSION = "0.5.14";
 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/package.json

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