@leg3ndy/otto-bridge 0.5.8 → 0.5.12

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.8";
+export const BRIDGE_VERSION = "0.5.12";
 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.8",
+  "version": "0.5.12",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",