@leg3ndy/otto-bridge 0.5.3 → 0.5.5

package/dist/config.js

@@ -33,6 +33,26 @@ function sanitizePollIntervalMs(value, fallback = DEFAULT_CLAWD_CURSOR_POLL_INTE
     }
     return Math.max(250, Math.floor(parsed));
 }
+export function normalizeInstalledExtensions(values) {
+    if (!Array.isArray(values)) {
+        return [];
+    }
+    const seen = new Set();
+    const normalized = [];
+    for (const item of values) {
+        const slug = String(item || "")
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9._-]+/g, "-")
+            .replace(/^-+|-+$/g, "");
+        if (!slug || seen.has(slug)) {
+            continue;
+        }
+        seen.add(slug);
+        normalized.push(slug);
+    }
+    return normalized;
+}
 function migrateLegacyExecutor(current) {
     if (platform() === "darwin"
         && current?.type === "clawd-cursor"
@@ -67,7 +87,11 @@ export async function loadBridgeConfig() {
             ...parsed,
             apiBaseUrl: sanitizeApiBaseUrl(parsed.apiBaseUrl),
             wsUrl: buildWebSocketUrl(parsed.apiBaseUrl),
+            // Older pairings may have persisted an outdated bridgeVersion in config.json.
+            // The runtime must always report the currently installed package version.
+            bridgeVersion: BRIDGE_VERSION,
             executor: resolveExecutorConfig(undefined, migrateLegacyExecutor(parsed.executor)),
+            installedExtensions: normalizeInstalledExtensions(parsed.installedExtensions),
         };
     }
     catch {
@@ -144,6 +168,7 @@ export function buildBridgeConfig(params) {
         approvalMode: params.approvalMode || "preview",
         capabilities: Array.isArray(params.capabilities) ? [...params.capabilities] : [],
         metadata: params.metadata || {},
+        installedExtensions: [],
         pairedAt: new Date().toISOString(),
         executor: resolveExecutorConfig(undefined, params.executor),
     };

package/dist/executors/native_macos.js

@@ -288,6 +288,12 @@ function clipText(value, maxLength) {
     }
     return `${value.slice(0, maxLength)}...`;
 }
+function clipTextPreview(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, maxLength)}\n\n[conteudo truncado: mostrando ${maxLength} de ${value.length} caracteres. Peca um trecho mais especifico se quiser continuar.]`;
+}
 const TEXTUTIL_READABLE_EXTENSIONS = new Set([
     ".doc",
     ".docx",
@@ -1020,6 +1026,8 @@ end tell
             title: page.title,
             url: page.url,
             text: page.text,
+            playerTitle: page.playerTitle || "",
+            playerState: page.playerState || "",
         };
     }
     resolveExpectedBrowserHref(rawHref, baseUrl) {
@@ -1058,6 +1066,22 @@ end tell
                 return true;
             }
         }
+        const beforePlayerTitle = normalizeText(before?.playerTitle || "");
+        const afterPlayerTitle = normalizeText(after.playerTitle || "");
+        const beforePlayerState = normalizeText(before?.playerState || "");
+        const afterPlayerState = normalizeText(after.playerState || "");
+        const playerLooksActive = afterPlayerState.includes("pause") || afterPlayerState.includes("pausar");
+        if (afterUrl.includes("music.youtube.com")) {
+            if (beforePlayerState && afterPlayerState && beforePlayerState !== afterPlayerState && playerLooksActive) {
+                return true;
+            }
+            if (beforePlayerTitle && afterPlayerTitle && beforePlayerTitle !== afterPlayerTitle) {
+                return true;
+            }
+            if (!beforePlayerTitle && afterPlayerTitle && playerLooksActive) {
+                return true;
+            }
+        }
         const beforeTitle = normalizeText(before?.title || "");
         const afterTitle = normalizeText(after.title || "");
         if (beforeTitle && afterTitle && beforeTitle !== afterTitle) {
@@ -1259,6 +1283,7 @@ const normalize = (value) => String(value || "")
   .replace(/[\\u0300-\\u036f]/g, "")
   .toLowerCase();
 const normalizedDescription = normalize(rawDescription);
+const isYouTubeMusic = location.hostname.includes("music.youtube.com");
 const wantsFirst = /\\b(primeir[ao]?|first)\\b/.test(normalizedDescription);
 const wantsVideo = /\\b(video|videos|musica|faixa|youtube|resultado|watch)\\b/.test(normalizedDescription) || location.hostname.includes("youtube");
 const stopWords = new Set([
@@ -1275,7 +1300,19 @@ const tokens = Array.from(new Set(
     .filter((token) => token.length >= 3 && !stopWords.has(token))
 ));
 
-const candidateSelectors = location.hostname.includes("youtube")
+const candidateSelectors = isYouTubeMusic
+  ? [
+      "ytmusic-responsive-list-item-renderer a[href*='watch?v=']",
+      "ytmusic-responsive-list-item-renderer button[aria-label]",
+      "ytmusic-responsive-list-item-renderer tp-yt-paper-icon-button",
+      "ytmusic-responsive-list-item-renderer ytmusic-item-thumbnail-overlay-renderer button",
+      "ytmusic-shelf-renderer ytmusic-responsive-list-item-renderer a[href*='watch?v=']",
+      "a[href*='watch?v=']",
+      "button",
+      "[role='button']",
+      "[role='link']"
+    ]
+  : location.hostname.includes("youtube")
   ? [
       "ytd-video-renderer a#video-title",
       "ytd-video-renderer ytd-thumbnail a",
@@ -1339,8 +1376,11 @@ function scoreCandidate(element, rank) {
 
   if (wantsFirst) score += Math.max(0, 40 - rank);
   if (wantsVideo && normalizedHref.includes("/watch")) score += 30;
+  if (isYouTubeMusic && normalizedHref.includes("watch?v=")) score += 36;
+  if (isYouTubeMusic && element.closest("ytmusic-responsive-list-item-renderer, ytmusic-player-bar")) score += 24;
   if (location.hostname.includes("youtube") && element.closest("ytd-video-renderer, ytd-rich-item-renderer, ytd-rich-grid-media")) score += 20;
   if (element.id === "video-title") score += 12;
+  if (isYouTubeMusic && /\\b(play|pause|reproduzir|tocar)\\b/.test(normalizedText)) score += 12;
   if (!normalizedText && normalizedHref.includes("/watch")) score += 8;
 
   for (const phrase of quotedPhrases) {
@@ -1445,7 +1485,7 @@ 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); return JSON.stringify({title:title,url:url,text:text});})();" in current tab of front window
+  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
 end tell
 return pageJson
 `;
@@ -1456,6 +1496,8 @@ return pageJson
                 title: asString(parsed.title) || "",
                 url: asString(parsed.url) || "",
                 text: asString(parsed.text) || "",
+                playerTitle: asString(parsed.playerTitle) || "",
+                playerState: asString(parsed.playerState) || "",
             };
         }
         catch (error) {
@@ -1478,6 +1520,8 @@ return pageTitle & linefeed & pageUrl
                 title: String(title || "").trim(),
                 url: String(url || "").trim(),
                 text: "",
+                playerTitle: "",
+                playerState: "",
             };
         }
     }
@@ -1715,7 +1759,7 @@ if let output = String(data: data, encoding: .utf8) {
             resized,
         };
     }
-    async readLocalFile(filePath, maxChars = 4000) {
+    async readLocalFile(filePath, maxChars = 1800) {
         const resolved = expandUserPath(filePath);
         const extension = path.extname(resolved).toLowerCase();
         if (TEXTUTIL_READABLE_EXTENSIONS.has(extension)) {
@@ -1726,7 +1770,7 @@ if let output = String(data: data, encoding: .utf8) {
                 resolved,
             ]);
             const content = sanitizeTextForJsonTransport(stdout);
-            return clipText(content || "(arquivo sem texto legivel)", maxChars);
+            return clipTextPreview(content || "(arquivo sem texto legivel)", maxChars);
         }
         const raw = await readFile(resolved);
         if (isLikelyBinaryBuffer(raw)) {
@@ -1735,7 +1779,7 @@ if let output = String(data: data, encoding: .utf8) {
             return clipText(`O arquivo ${filename} parece ser binario (${detectedType}) e nao pode ser lido como texto puro pelo Otto Bridge ainda.`, maxChars);
         }
         const content = sanitizeTextForJsonTransport(raw.toString("utf8"));
-        return clipText(content || "(arquivo vazio)", maxChars);
+        return clipTextPreview(content || "(arquivo vazio)", maxChars);
     }
     async listLocalFiles(directoryPath, limit = 40) {
         const resolved = expandUserPath(directoryPath);

package/dist/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import process from "node:process";
-import { clearBridgeConfig, getBridgeConfigPath, loadBridgeConfig, resolveApiBaseUrl, resolveExecutorConfig, } from "./config.js";
+import { clearBridgeConfig, getBridgeConfigPath, loadBridgeConfig, normalizeInstalledExtensions, resolveApiBaseUrl, resolveExecutorConfig, saveBridgeConfig, } from "./config.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";
@@ -56,6 +56,9 @@ function printUsage() {
   otto-bridge pair --api http://localhost:8000 --code ABC123 [--name "Meu PC"] [--executor native-macos|mock|clawd-cursor]
   otto-bridge run [--executor native-macos|mock|clawd-cursor] [--clawd-url http://127.0.0.1:3847]
   otto-bridge status
+  otto-bridge extensions --list
+  otto-bridge extensions --install github
+  otto-bridge extensions --uninstall github
   otto-bridge version
   otto-bridge update [--tag latest|next] [--dry-run]
   otto-bridge unpair
@@ -63,6 +66,8 @@ 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 --list
   otto-bridge version
   otto-bridge update
   otto-bridge update --dry-run
@@ -108,11 +113,15 @@ async function runPairCommand(args) {
     console.log(`[otto-bridge] config=${getBridgeConfigPath()}`);
     console.log("[otto-bridge] next step: run `otto-bridge run` to keep this device online");
 }
-async function runRuntimeCommand(args) {
+async function loadRequiredBridgeConfig() {
     const config = await loadBridgeConfig();
     if (!config) {
         throw new Error("No local pairing found. Run `otto-bridge pair --code <CODE>` first.");
     }
+    return config;
+}
+async function runRuntimeCommand(args) {
+    const config = await loadRequiredBridgeConfig();
     const runtimeConfig = {
         ...config,
         executor: resolveExecutorOverrides(args, config.executor),
@@ -136,10 +145,61 @@ async function runStatusCommand() {
         ws_url: config.wsUrl,
         approval_mode: config.approvalMode,
         capabilities: config.capabilities,
+        installed_extensions: config.installedExtensions,
         paired_at: config.pairedAt,
         executor: config.executor,
     }, null, 2));
 }
+async function runExtensionsCommand(args) {
+    const config = await loadRequiredBridgeConfig();
+    const installValue = option(args, "install");
+    const uninstallValue = option(args, "uninstall");
+    if (installValue && uninstallValue) {
+        throw new Error("Use apenas uma acao por vez: --install ou --uninstall.");
+    }
+    if (installValue) {
+        const nextExtensions = normalizeInstalledExtensions([
+            ...config.installedExtensions,
+            ...installValue.split(","),
+        ]);
+        const added = nextExtensions.filter((item) => !config.installedExtensions.includes(item));
+        if (!added.length) {
+            console.log("[otto-bridge] nenhuma extensao nova para instalar");
+            return;
+        }
+        await saveBridgeConfig({
+            ...config,
+            installedExtensions: nextExtensions,
+        });
+        console.log(`[otto-bridge] extensoes instaladas: ${added.join(", ")}`);
+        console.log("[otto-bridge] rode `otto-bridge run` novamente se quiser sincronizar agora com a web");
+        return;
+    }
+    if (uninstallValue) {
+        const removeSet = new Set(normalizeInstalledExtensions(uninstallValue.split(",")));
+        const nextExtensions = config.installedExtensions.filter((item) => !removeSet.has(item));
+        const removed = config.installedExtensions.filter((item) => removeSet.has(item));
+        if (!removed.length) {
+            console.log("[otto-bridge] nenhuma extensao correspondente estava instalada");
+            return;
+        }
+        await saveBridgeConfig({
+            ...config,
+            installedExtensions: nextExtensions,
+        });
+        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;
+    }
+    if (!config.installedExtensions.length) {
+        console.log("[otto-bridge] nenhuma extensao instalada");
+        return;
+    }
+    console.log("[otto-bridge] extensoes instaladas:");
+    for (const extension of config.installedExtensions) {
+        console.log(`- ${extension}`);
+    }
+}
 async function runUnpairCommand() {
     await clearBridgeConfig();
     console.log("[otto-bridge] local pairing cleared");
@@ -173,6 +233,9 @@ async function main() {
         case "status":
             await runStatusCommand();
             return;
+        case "extensions":
+            await runExtensionsCommand(args);
+            return;
         case "version":
             printVersion();
             return;

package/dist/runtime.js

@@ -6,6 +6,52 @@ import { JobCancelledError } from "./executors/shared.js";
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function parseSemverTuple(value) {
+    const text = String(value || "").trim().replace(/^[vV]/, "");
+    if (!text) {
+        return null;
+    }
+    const parts = text.split(".");
+    const parsed = [];
+    for (const part of parts) {
+        const match = part.match(/^(\d+)/);
+        if (!match) {
+            return null;
+        }
+        parsed.push(Number(match[1]));
+    }
+    return parsed.length > 0 ? parsed : null;
+}
+function compareSemver(left, right) {
+    const a = parseSemverTuple(left);
+    const b = parseSemverTuple(right);
+    if (!a && !b)
+        return 0;
+    if (!a)
+        return -1;
+    if (!b)
+        return 1;
+    const maxLength = Math.max(a.length, b.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftPart = a[index] ?? 0;
+        const rightPart = b[index] ?? 0;
+        if (leftPart < rightPart)
+            return -1;
+        if (leftPart > rightPart)
+            return 1;
+    }
+    return 0;
+}
+function bridgeReleaseFromMessage(message) {
+    const nested = message.bridge_release;
+    if (nested && typeof nested === "object") {
+        return nested;
+    }
+    if (message.latest_version || message.min_supported_version || message.update_command) {
+        return message;
+    }
+    return null;
+}
 async function parseSocketMessage(data) {
     if (typeof data === "string") {
         return JSON.parse(data);
@@ -25,6 +71,7 @@ export class BridgeRuntime {
     config;
     reconnectDelayMs = DEFAULT_RECONNECT_BASE_DELAY_MS;
     executor;
+    lastBridgeReleaseNoticeKey = null;
     pendingConfirmations = new Map();
     activeCancels = new Map();
     constructor(config, executor) {
@@ -71,7 +118,10 @@ export class BridgeRuntime {
                     device_name: this.config.deviceName,
                     bridge_version: this.config.bridgeVersion,
                     capabilities: this.config.capabilities,
-                    metadata: this.config.metadata,
+                    metadata: {
+                        ...(this.config.metadata || {}),
+                        installed_extensions: this.config.installedExtensions,
+                    },
                 }));
                 heartbeatTimer = setInterval(() => {
                     if (socket.readyState === WebSocket.OPEN) {
@@ -119,6 +169,7 @@ export class BridgeRuntime {
                 console.log(`[otto-bridge] server hello device=${String(message.device_id || "")}`);
                 return;
             case "device.hello_ack":
+                this.maybeLogBridgeReleaseNotice(message);
             case "device.heartbeat_ack":
                 return;
             case "device.job.start":
@@ -145,6 +196,29 @@ export class BridgeRuntime {
                 console.log(`[otto-bridge] event=${type || "unknown"} payload=${JSON.stringify(message)}`);
         }
     }
+    maybeLogBridgeReleaseNotice(message) {
+        const release = bridgeReleaseFromMessage(message);
+        if (!release) {
+            return;
+        }
+        const latestVersion = String(release.latest_version || "").trim();
+        const minSupportedVersion = String(release.min_supported_version || "").trim();
+        const updateCommand = String(release.update_command || "otto-bridge update").trim() || "otto-bridge update";
+        const updateRequired = release.update_required === true || (minSupportedVersion ? compareSemver(this.config.bridgeVersion, minSupportedVersion) < 0 : false);
+        const updateAvailable = release.update_available === true || (latestVersion ? compareSemver(this.config.bridgeVersion, latestVersion) < 0 : false);
+        const noticeKey = [latestVersion, minSupportedVersion, updateRequired ? "req" : "ok", updateAvailable ? "avail" : "cur"].join("|");
+        if (!noticeKey.trim() || this.lastBridgeReleaseNoticeKey === noticeKey) {
+            return;
+        }
+        this.lastBridgeReleaseNoticeKey = noticeKey;
+        if (updateRequired) {
+            console.warn(`[otto-bridge] update required current=${this.config.bridgeVersion} min_supported=${minSupportedVersion || "unknown"} latest=${latestVersion || "unknown"} command="${updateCommand}"`);
+            return;
+        }
+        if (updateAvailable) {
+            console.log(`[otto-bridge] update available current=${this.config.bridgeVersion} latest=${latestVersion || "unknown"} command="${updateCommand}"`);
+        }
+    }
     resolveConfirmation(message) {
         const jobId = String(message.job_id || "");
         const action = String(message.action || "").trim().toLowerCase();

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "0.5.3";
+export const BRIDGE_VERSION = "0.5.5";
 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.3",
+  "version": "0.5.5",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",