@leg3ndy/otto-bridge 0.6.2 → 0.6.4

package/README.md

@@ -33,10 +33,10 @@ Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./leg3ndy-otto-bridge-0.6.2.tgz
+npm install -g ./leg3ndy-otto-bridge-0.6.4.tgz
 ```
 
-No `0.6.2`, `playwright` deixa de ser opcional no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
+No `0.6.4`, `playwright` deixa de ser opcional no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
 
 ## Publicacao
 
@@ -106,7 +106,7 @@ otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
 
 ### WhatsApp Web em background
 
-Fluxo recomendado no `0.6.2`:
+Fluxo recomendado no `0.6.4`:
 
 ```bash
 otto-bridge extensions --install whatsappweb
@@ -116,7 +116,7 @@ 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.
 
-Contrato do `0.6.2`:
+Contrato do `0.6.4`:
 
 - `otto-bridge extensions --setup whatsappweb`: autentica a sessao uma vez
 - `otto-bridge run`: mantem o browser persistente do WhatsApp vivo em background enquanto o runtime estiver ativo

package/dist/main.js

@@ -8,6 +8,7 @@ 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";
 const RUNTIME_STATUS_FRESHNESS_MS = 90_000;
+const UPDATE_RETRY_DELAYS_MS = [0, 8_000, 20_000];
 function parseArgs(argv) {
     const [maybeCommand, ...rest] = argv;
     if (maybeCommand === "--help" || maybeCommand === "-h") {
@@ -54,6 +55,42 @@ function hasFreshRuntimeAttachment(state) {
     const lastHeartbeatAt = Date.parse(state.lastRuntimeHeartbeatAt);
     return Number.isFinite(lastHeartbeatAt) && Date.now() - lastHeartbeatAt <= RUNTIME_STATUS_FRESHNESS_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 resolveExecutorOverrides(args, current) {
     return resolveExecutorConfig({
         type: option(args, "executor") || process.env.OTTO_BRIDGE_EXECUTOR,
@@ -108,6 +145,85 @@ function runChildCommand(command, args) {
         });
     });
 }
+function runChildCommandCapture(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += String(chunk || "");
+        });
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            stderr += String(chunk || "");
+        });
+        child.on("error", (error) => {
+            reject(error);
+        });
+        child.on("exit", (code) => {
+            resolve({
+                stdout,
+                stderr,
+                code: code ?? 1,
+            });
+        });
+    });
+}
+async function resolvePublishedPackageVersion(tag) {
+    const command = process.platform === "win32" ? "npm.cmd" : "npm";
+    const result = await runChildCommandCapture(command, [
+        "view",
+        `${BRIDGE_PACKAGE_NAME}@${tag}`,
+        "version",
+        "--json",
+    ]).catch(() => null);
+    if (!result || result.code !== 0) {
+        return null;
+    }
+    const stdout = String(result.stdout || "").trim();
+    if (!stdout) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(stdout);
+        if (typeof parsed === "string" && parsed.trim()) {
+            return parsed.trim();
+        }
+    }
+    catch {
+        if (stdout && stdout !== "null") {
+            return stdout.replace(/^"|"$/g, "").trim() || null;
+        }
+    }
+    return null;
+}
+async function resolveActiveCliVersion() {
+    const binary = process.platform === "win32" ? "otto-bridge.cmd" : "otto-bridge";
+    const result = await runChildCommandCapture(binary, ["version"]).catch(() => null);
+    if (!result || result.code !== 0) {
+        return null;
+    }
+    const output = String(result.stdout || "").trim();
+    const match = output.match(/@leg3ndy\/otto-bridge\s+([0-9]+(?:\.[0-9]+){1,3})/i);
+    return match?.[1]?.trim() || null;
+}
+function isRetryableNpmUpdateFailure(detail) {
+    const normalized = String(detail || "").toLowerCase();
+    return [
+        "code etarget",
+        "no matching version found",
+        "notarget",
+        "code enoversions",
+        "package version that doesn't exist",
+    ].some((pattern) => normalized.includes(pattern));
+}
+async function delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function openManagedExtensionSetup(slug) {
     const definition = getManagedBridgeExtensionDefinition(slug);
     if (process.platform !== "darwin") {
@@ -385,20 +501,75 @@ async function runUnpairCommand() {
 }
 async function runUpdateCommand(args) {
     const tag = option(args, "tag") || "latest";
-    const packageSpec = `${BRIDGE_PACKAGE_NAME}@${tag}`;
+    const publishedVersion = await resolvePublishedPackageVersion(tag);
+    if (publishedVersion && compareSemver(publishedVersion, BRIDGE_VERSION) <= 0) {
+        console.log(`[otto-bridge] current=${BRIDGE_VERSION}`);
+        console.log(`[otto-bridge] latest published=${publishedVersion}`);
+        console.log("[otto-bridge] nenhuma atualizacao mais nova publicada no npm no momento");
+        return;
+    }
+    const packageSpec = `${BRIDGE_PACKAGE_NAME}@${publishedVersion || tag}`;
     const command = process.platform === "win32" ? "npm.cmd" : "npm";
-    const commandArgs = ["install", "-g", packageSpec];
+    const commandArgs = ["install", "-g", packageSpec, "--prefer-online"];
     const commandString = `${command} ${commandArgs.join(" ")}`;
     if (args.options.has("dry-run") || args.options.has("check")) {
         console.log(`[otto-bridge] current=${BRIDGE_VERSION}`);
+        if (publishedVersion) {
+            console.log(`[otto-bridge] target=${publishedVersion}`);
+        }
         console.log(`[otto-bridge] update command: ${commandString}`);
         return;
     }
     console.log(`[otto-bridge] current=${BRIDGE_VERSION}`);
+    if (publishedVersion) {
+        console.log(`[otto-bridge] target=${publishedVersion}`);
+    }
     console.log(`[otto-bridge] updating with: ${commandString}`);
-    await runChildCommand(command, commandArgs);
-    console.log("[otto-bridge] update completed");
-    console.log("[otto-bridge] run `otto-bridge version` to confirm the installed version");
+    let lastFailureDetail = "";
+    for (let attemptIndex = 0; attemptIndex < UPDATE_RETRY_DELAYS_MS.length; attemptIndex += 1) {
+        const waitMs = UPDATE_RETRY_DELAYS_MS[attemptIndex];
+        if (waitMs > 0) {
+            console.log(`[otto-bridge] aguardando ${Math.round(waitMs / 1000)}s para tentar novamente...`);
+            await delay(waitMs);
+        }
+        const result = await runChildCommandCapture(command, commandArgs).catch((error) => ({
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            code: 1,
+        }));
+        if (result.stdout.trim()) {
+            process.stdout.write(result.stdout);
+        }
+        if (result.stderr.trim()) {
+            process.stderr.write(result.stderr);
+        }
+        if (result.code === 0) {
+            const activeVersion = await resolveActiveCliVersion();
+            if (!publishedVersion) {
+                console.log("[otto-bridge] update completed");
+                console.log("[otto-bridge] run `otto-bridge version` to confirm the installed version");
+                return;
+            }
+            if (activeVersion && compareSemver(activeVersion, publishedVersion) >= 0) {
+                console.log(`[otto-bridge] update completed active=${activeVersion}`);
+                return;
+            }
+            const observedVersion = activeVersion || BRIDGE_VERSION;
+            throw new Error(`[otto-bridge] O npm concluiu o install, mas o comando \`otto-bridge\` ainda responde ${observedVersion}. `
+                + `A atualizacao para ${publishedVersion} nao ficou ativa neste PATH ainda.\n`
+                + `[otto-bridge] Tente abrir um novo terminal e rodar \`otto-bridge version\`.\n`
+                + `[otto-bridge] Se continuar igual, rode manualmente: npm install -g ${BRIDGE_PACKAGE_NAME}@${publishedVersion} --prefer-online`);
+        }
+        lastFailureDetail = `${command} exited with code ${result.code}\n${result.stderr || result.stdout}`.trim();
+        const retryable = isRetryableNpmUpdateFailure(lastFailureDetail);
+        const hasNextAttempt = attemptIndex < UPDATE_RETRY_DELAYS_MS.length - 1;
+        if (!retryable || !hasNextAttempt) {
+            break;
+        }
+        console.log("[otto-bridge] A release ainda pode estar propagando no npm. Vou tentar novamente com cache online.");
+    }
+    const hintSpec = `${BRIDGE_PACKAGE_NAME}@${publishedVersion || tag}`;
+    throw new Error(`${lastFailureDetail}\n[otto-bridge] Se a release acabou de ser publicada, isso costuma ser propagacao do npm.\n[otto-bridge] Fallback manual: npm install -g ${hintSpec} --prefer-online`);
 }
 async function main() {
     const args = parseArgs(process.argv.slice(2));

package/dist/types.js

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