@leg3ndy/otto-bridge 1.0.0 → 1.0.1

package/README.md

@@ -15,7 +15,7 @@ Para o estado atual da arquitetura, capacidades entregues, limitacoes e roadmap
 
 Para o corte de arquitetura do `0.9.0`, veja [`leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_0_RELEASE.md`](../leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_0_RELEASE.md).
 
-Para a release atual `1.0.0`, com runtime agentico formal e CLI interativo do bridge, veja [`leg3ndy-ai-backend/docs/OTTO_BRIDGE_1_0_0_RELEASE.md`](../leg3ndy-ai-backend/docs/OTTO_BRIDGE_1_0_0_RELEASE.md).
+Para a release atual `1.0.1`, com runtime agentico formal, hub terminal e console alinhado ao Otto da web, veja [`leg3ndy-ai-backend/docs/OTTO_BRIDGE_1_0_1_PATCH.md`](../leg3ndy-ai-backend/docs/OTTO_BRIDGE_1_0_1_PATCH.md).
 
 ## Distribuicao
 
@@ -38,14 +38,14 @@ Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./leg3ndy-otto-bridge-1.0.0.tgz
+npm install -g ./leg3ndy-otto-bridge-1.0.1.tgz
 ```
 
-Na linha `1.0.0`, `playwright` segue como dependencia obrigatoria 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.
+Na linha `1.0.1`, `playwright` segue como dependencia obrigatoria 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 macOS, a linha `1.0.0` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
+No macOS, a linha `1.0.1` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
 
-No nivel arquitetural, o `0.9.0` marcou a mudanca de papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat. O `1.0.0` oficializa isso como runtime agentico e adiciona uma interface terminal propria do bridge para setup e interacao local com o Otto.
+No nivel arquitetural, o `0.9.0` marcou a mudanca de papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat. O `1.0.0` oficializou isso como runtime agentico; o `1.0.1` consolida o hub terminal como fluxo principal e alinha o console ao comportamento normal do Otto antes de fazer handoff local.
 
 ## Publicacao
 
@@ -76,14 +76,14 @@ otto-bridge help
 otto-bridge --help
 ```
 
-### Abrir o hub interativo
+### Abrir o hub interativo e ligar o runtime
 
 ```bash
 otto-bridge
 otto-bridge home
 ```
 
-Em TTY, o comando sem argumentos agora abre o hub interativo com banner, setup, status, extensoes e o `Otto Console`.
+Em TTY, o comando sem argumentos agora abre o hub interativo com banner, setup, status, extensoes e o `Otto Console`. Se ja existir pairing salvo, o próprio `otto-bridge` sobe o runtime local automaticamente e mostra o estado da conexão no hub.
 
 ### Setup interativo
 
@@ -110,24 +110,26 @@ Opcoes suportadas:
 
 No macOS, o caminho recomendado agora e o executor nativo do Otto Bridge. Se nenhum `--executor` for informado, o `pair` usa `native-macos` por padrao no Mac.
 
-### Rodar o bridge
+### Runtime principal do bridge
 
 ```bash
-otto-bridge run
+otto-bridge
 ```
 
-Se o executor estiver salvo no `config.json`, o `run` usa essa configuracao por padrao.
+Esse agora e o fluxo principal do produto: o hub abre, conecta o runtime local e deixa o Otto pronto para handoff e approvals sem depender de um `run` separado.
 
-Para forcar o executor nativo no macOS sem reparar:
+Se precisar do executor nativo no macOS sem reparar, atualize o pairing/config e reabra o hub:
 
 ```bash
-otto-bridge run --executor native-macos
+otto-bridge setup
 ```
 
-O adapter `clawd-cursor` continua disponivel como override opcional:
+`otto-bridge run` continua existindo apenas como alias legado/headless para compatibilidade operacional.
+
+O adapter `clawd-cursor` continua disponivel como override opcional no pairing legado:
 
 ```bash
-otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
+otto-bridge pair --executor clawd-cursor --clawd-url http://127.0.0.1:3847
 ```
 
 ### Falar com o Otto no terminal
@@ -136,11 +138,11 @@ otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
 otto-bridge console
 ```
 
-O console sobe o runtime local em background no mesmo processo, envia prompts naturais ao backend usando `device_token`, acompanha `device_job` por polling e resolve `confirm_required` diretamente no terminal.
+O console usa a mesma sessão local já ligada pelo `otto-bridge`, envia prompts naturais ao backend usando `device_token`, respeita quota/plano do usuário e só vira handoff local quando o pedido realmente tiver cara de ação no computador. Quando houver `device_job`, ele acompanha polling e resolve `confirm_required` no terminal.
 
 ### WhatsApp Web em background
 
-Fluxo recomendado na linha `1.0.0`:
+Fluxo recomendado na linha `1.0.1`:
 
 ```bash
 otto-bridge extensions --install whatsappweb
@@ -150,13 +152,13 @@ otto-bridge extensions --status whatsappweb
 
 O setup agora abre o login do WhatsApp Web no helper/background browser do proprio bridge. Depois do QR code, o Otto usa a sessao local em background, sem depender de aba visivel no Safari.
 
-Contrato da linha `1.0.0`:
+Contrato da linha `1.0.1`:
 
 - `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, sem depender de uma aba aberta no Safari
-- ao parar o `otto-bridge run`: o browser em background e desligado, mas a sessao local fica lembrada para o proximo boot
+- `otto-bridge`: mantem o browser persistente do WhatsApp vivo em background enquanto o runtime do hub estiver ativo, sem depender de uma aba aberta no Safari
+- ao fechar o `otto-bridge`: o browser em background e desligado, mas a sessao local fica lembrada para o proximo boot
 
-## Handoff rapido da linha 1.0.0
+## Handoff rapido da linha 1.0.1
 
 Ja fechado no codigo:
 
@@ -190,8 +192,8 @@ Ja fechado no codigo:
 - o `instruction_updater` agora e um descriptor explicito do runtime, com `source_entrypoints`, `target_paths` e `recommended_validation_stage_ids` quando o plano toca `AGENTS.md`, `README.md` ou `docs/`
 - `workspace.tests` agora consegue resolver `profile=auto` via `validation_ladder`, executando stages como `typecheck`, `build`, `node_test`, `lint` e `pytest` por stack, com snapshot agregado por etapa
 - o executor `native-macos` agora publica `runtime_hook_trace` somando hooks de lifecycle e tool-use (`session_start`, `pre_tool_use`, `post_tool_use`, `validation_ladder_started/completed`, `session_end`), preparando enforcement, replay fino e metricas futuras
-- o bridge agora possui um CLI interativo proprio com setup inicial, hub terminal e `Otto Console` para prompts locais pelo proprio terminal
-- o backend agora expoe um caminho `device-auth` para o console do bridge submeter prompt e acompanhar approval/job usando apenas `device_token`
+- o bridge agora possui um CLI interativo proprio com setup inicial, hub terminal e `Otto Console` para conversar com o Otto pelo proprio terminal
+- o backend agora expoe caminhos `device-auth` para o console do bridge usar chat com quota/plano (`/v1/devices/cli/chat/completions`) e acompanhar approval/job usando apenas `device_token`
 - o caminho principal do bridge usa `summary`/`narration_context` no lugar de resposta automatica pronta
 - `read_file` agora entrega conteudo completo segmentado em `content_chunks` para o Otto
 - `list_files` sem `limit` agora lista o diretorio inteiro, sem fallback silencioso para 40 itens

package/dist/chat_cli_client.js

@@ -0,0 +1,91 @@
+function normalizeBaseUrl(apiBaseUrl) {
+    return String(apiBaseUrl || "").trim().replace(/\/+$/, "");
+}
+function buildDeviceAuthHeaders(deviceToken, headers) {
+    const next = new Headers(headers || {});
+    if (deviceToken) {
+        next.set("Authorization", `Bearer ${deviceToken}`);
+    }
+    return next;
+}
+function parseApiError(payload, fallbackStatus) {
+    if (payload && typeof payload === "object") {
+        const detail = "detail" in payload ? payload.detail : null;
+        if (typeof detail === "string" && detail.trim()) {
+            return new Error(detail.trim());
+        }
+        if (detail && typeof detail === "object") {
+            const message = "message" in detail ? detail.message : null;
+            if (typeof message === "string" && message.trim()) {
+                return new Error(message.trim());
+            }
+        }
+        const error = "error" in payload ? payload.error : null;
+        if (typeof error === "string" && error.trim()) {
+            return new Error(error.trim());
+        }
+    }
+    return new Error(`HTTP ${fallbackStatus}`);
+}
+export async function streamDeviceCliChat(config, request, onEvent) {
+    const url = `${normalizeBaseUrl(config.apiBaseUrl)}/v1/devices/cli/chat/completions`;
+    let response;
+    try {
+        response = await fetch(url, {
+            method: "POST",
+            headers: buildDeviceAuthHeaders(config.deviceToken, {
+                "Content-Type": "application/json",
+            }),
+            body: JSON.stringify(request),
+        });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Request failed for ${url}: ${detail}`);
+    }
+    if (!response.ok) {
+        const payload = await response.json().catch(() => null);
+        throw parseApiError(payload, response.status);
+    }
+    if (!response.body) {
+        throw new Error("Empty stream response");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const flushBlock = async (rawBlock) => {
+        const lines = rawBlock
+            .split("\n")
+            .map((line) => line.trimEnd())
+            .filter((line) => line.startsWith("data:"));
+        if (!lines.length) {
+            return;
+        }
+        const payloadText = lines
+            .map((line) => line.slice(5).trimStart())
+            .join("\n")
+            .trim();
+        if (!payloadText) {
+            return;
+        }
+        const payload = JSON.parse(payloadText);
+        await onEvent(payload);
+    };
+    for (;;) {
+        const { done, value } = await reader.read();
+        buffer += decoder.decode(value || new Uint8Array(), { stream: !done });
+        let separatorIndex = buffer.indexOf("\n\n");
+        while (separatorIndex >= 0) {
+            const block = buffer.slice(0, separatorIndex);
+            buffer = buffer.slice(separatorIndex + 2);
+            await flushBlock(block);
+            separatorIndex = buffer.indexOf("\n\n");
+        }
+        if (done) {
+            break;
+        }
+    }
+    if (buffer.trim()) {
+        await flushBlock(buffer);
+    }
+}

package/dist/cli_terminal.js

@@ -2,10 +2,11 @@ import { randomUUID } from "node:crypto";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { defaultDeviceName, getBridgeConfigPath, loadBridgeConfig, resolveApiBaseUrl, resolveExecutorConfig, } from "./config.js";
+import { streamDeviceCliChat, } from "./chat_cli_client.js";
 import { formatManagedBridgeExtensionStatus, isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, } from "./extensions.js";
 import { pairDevice } from "./pairing.js";
-import { BridgeRuntime } from "./runtime.js";
-import { cancelRuntimeCliJob, confirmRuntimeCliJob, getRuntimeCliJob, submitRuntimeCliAssistantPrompt, } from "./runtime_cli_client.js";
+import { BridgeRuntime, } from "./runtime.js";
+import { cancelRuntimeCliJob, confirmRuntimeCliJob, getRuntimeCliJob, } from "./runtime_cli_client.js";
 import { BRIDGE_PACKAGE_NAME, BRIDGE_VERSION, DEFAULT_API_BASE_URL, } from "./types.js";
 const ANSI = {
     reset: "\u001b[0m",
@@ -27,6 +28,123 @@ const OTTOAI_BANNER = [
     "╚██████╔╝   ██║      ██║   ╚██████╔╝    ██║  ██║██║",
     " ╚═════╝    ╚═╝      ╚═╝    ╚═════╝     ╚═╝  ╚═╝╚═╝",
 ];
+class CliRuntimeSession {
+    config;
+    runtime = null;
+    runtimeTask = null;
+    status = "offline";
+    detail = "Aguardando pairing.";
+    lastError = null;
+    constructor(config) {
+        this.config = config;
+    }
+    handleRuntimeEvent(event) {
+        switch (event.type) {
+            case "starting":
+                this.status = "starting";
+                this.detail = "Conectando o runtime local do Otto Bridge...";
+                return;
+            case "connected":
+                this.status = "online";
+                this.detail = "Runtime conectado ao backend e pronto para handoff local.";
+                return;
+            case "server_hello":
+                this.status = "online";
+                this.detail = "Handshake com o backend concluído.";
+                return;
+            case "reconnecting":
+                this.status = "reconnecting";
+                this.detail = `Reconectando em ${Math.max(1, Math.round(event.delayMs / 1000))}s...`;
+                return;
+            case "socket_error":
+                this.status = "error";
+                this.lastError = event.message;
+                this.detail = truncate(event.message || "Falha de conexão do runtime.", 160);
+                return;
+            case "socket_closed":
+                if (this.status !== "error") {
+                    this.status = "offline";
+                    this.detail = `Socket fechado (code=${event.code}).`;
+                }
+                return;
+            case "update_required":
+            case "update_available":
+                this.detail = truncate(event.message || this.detail, 160);
+                return;
+            default:
+                return;
+        }
+    }
+    async ensureStarted() {
+        if (this.runtimeTask) {
+            return;
+        }
+        this.status = "starting";
+        this.detail = "Subindo runtime local do Otto Bridge...";
+        this.runtime = new BridgeRuntime(this.config, undefined, {
+            logger: {
+                info: () => undefined,
+                warn: () => undefined,
+                error: () => undefined,
+                event: (event) => {
+                    this.handleRuntimeEvent(event);
+                },
+            },
+        });
+        this.runtimeTask = this.runtime.start().catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            this.status = "error";
+            this.lastError = detail;
+            this.detail = truncate(detail || "Falha ao iniciar o runtime.", 160);
+        });
+        await delay(350);
+    }
+    async replaceConfig(nextConfig) {
+        await this.stop();
+        this.config = nextConfig;
+        this.status = "offline";
+        this.detail = "Reinicializando runtime com o novo pairing...";
+        this.lastError = null;
+        await this.ensureStarted();
+    }
+    async stop() {
+        const runtime = this.runtime;
+        const runtimeTask = this.runtimeTask;
+        this.runtime = null;
+        this.runtimeTask = null;
+        if (runtime) {
+            await runtime.stop().catch(() => undefined);
+        }
+        if (runtimeTask) {
+            await runtimeTask.catch(() => undefined);
+        }
+        if (this.status !== "error") {
+            this.status = "offline";
+            this.detail = "Runtime local desligado.";
+        }
+    }
+    getStatusLabel() {
+        if (this.status === "online") {
+            return "online";
+        }
+        if (this.status === "starting") {
+            return "starting";
+        }
+        if (this.status === "reconnecting") {
+            return "reconnecting";
+        }
+        if (this.status === "error") {
+            return "error";
+        }
+        return "offline";
+    }
+    getStatusDetail() {
+        return this.detail;
+    }
+    getLastError() {
+        return this.lastError;
+    }
+}
 function style(text, color, enabled = true) {
     if (!enabled) {
         return text;
@@ -123,16 +241,20 @@ async function chooseExecutor(rl, current) {
     }
     return { type: "native-macos" };
 }
-function extractResponseSummary(response) {
-    const narrationContext = response.narration_context && typeof response.narration_context === "object"
-        ? response.narration_context
+function extractBridgeHandoffSummary(payload) {
+    const narrationContext = payload.narration_context && typeof payload.narration_context === "object"
+        ? payload.narration_context
+        : {};
+    const plan = payload.plan && typeof payload.plan === "object"
+        ? payload.plan
         : {};
-    const plan = response.plan && typeof response.plan === "object"
-        ? response.plan
+    const job = payload.job && typeof payload.job === "object"
+        ? payload.job
         : {};
     return normalizeText(narrationContext.summary
         || plan.summary
-        || plan.assistant_message);
+        || plan.assistant_message
+        || extractJobSummary(job));
 }
 function extractJobStepId(job) {
     return normalizeText(job.runtime_current_step_id
@@ -169,13 +291,17 @@ function extractConfirmationPrompt(job) {
         || payload.kernel_confirmation_summary
         || payload.confirmation_message) || "O Otto está aguardando sua confirmação para continuar.";
 }
-function renderStatusOverview(config) {
+function renderStatusOverview(config, runtimeSession) {
     return [
         `${style("Device", ANSI.blue, supportsAnsi())}: ${config.deviceName}`,
         `${style("Device ID", ANSI.blue, supportsAnsi())}: ${config.deviceId}`,
         `${style("API", ANSI.blue, supportsAnsi())}: ${config.apiBaseUrl}`,
         `${style("Executor", ANSI.blue, supportsAnsi())}: ${config.executor.type}`,
         `${style("Approval", ANSI.blue, supportsAnsi())}: ${config.approvalMode}`,
+        `${style("Runtime", ANSI.blue, supportsAnsi())}: ${runtimeSession?.getStatusLabel() || "offline"}`,
+        ...(runtimeSession?.getStatusDetail()
+            ? [`${style("Runtime note", ANSI.blue, supportsAnsi())}: ${runtimeSession.getStatusDetail()}`]
+            : []),
         `${style("Config", ANSI.blue, supportsAnsi())}: ${getBridgeConfigPath()}`,
     ];
 }
@@ -281,15 +407,10 @@ async function followConsoleJob(rl, config, jobId) {
         await delay(1400);
     }
 }
-async function runOttoConsole(rl, config, options) {
+async function runOttoConsole(rl, config, runtimeSession, options) {
     printSection("Otto Console");
-    printMuted("O runtime local será mantido em background enquanto este console estiver aberto.");
-    const runtime = new BridgeRuntime(config);
-    let runtimeFailure = null;
-    const runtimeTask = runtime.start().catch((error) => {
-        runtimeFailure = error instanceof Error ? error.message : String(error);
-    });
-    await delay(600);
+    printMuted("Este console usa o mesmo runtime local já ligado pelo `otto-bridge`.");
+    printMuted(`Runtime: ${runtimeSession.getStatusLabel()} · ${runtimeSession.getStatusDetail()}`);
     const sessionId = randomUUID();
     const conversation = [];
     const printConsoleHelp = () => {
@@ -310,7 +431,8 @@ async function runOttoConsole(rl, config, options) {
             return;
         }
         if (normalizedPrompt === "/status") {
-            renderStatusOverview(config).forEach((line) => console.log(line));
+            renderStatusOverview(config, runtimeSession).forEach((line) => console.log(line));
+            const runtimeFailure = runtimeSession.getLastError();
             if (runtimeFailure) {
                 printWarning(`Runtime reportou erro: ${runtimeFailure}`);
             }
@@ -319,62 +441,94 @@ async function runOttoConsole(rl, config, options) {
         if (normalizedPrompt === "/exit") {
             throw new Error("__OTTO_CONSOLE_EXIT__");
         }
+        conversation.push({ role: "user", content: normalizedPrompt });
+        while (conversation.length > 18) {
+            conversation.shift();
+        }
         console.log(`${style("você", ANSI.white, supportsAnsi())} ${normalizedPrompt}`);
-        const response = await submitRuntimeCliAssistantPrompt(config, {
-            prompt: normalizedPrompt,
-            conversation,
+        let streamedAssistant = "";
+        let assistantPrefixPrinted = false;
+        let handoffPayload = null;
+        await streamDeviceCliChat(config, {
+            messages: conversation,
             session_id: sessionId,
-            source: "cli_terminal",
+        }, async (event) => {
+            const chunkType = normalizeText(event.chunk_type).toLowerCase();
+            const eventType = normalizeText(event.type).toLowerCase();
+            if (chunkType === "bridge_handoff") {
+                handoffPayload = event;
+                return;
+            }
+            if (chunkType === "search_status") {
+                const status = normalizeText(event.status);
+                if (status) {
+                    printMuted(`Busca: ${status}`);
+                }
+                return;
+            }
+            const errorMessage = normalizeText(event.error || (eventType === "error" ? event.content : ""));
+            if (errorMessage) {
+                throw new Error(errorMessage);
+            }
+            const contentChunk = typeof event.content === "string" ? event.content : "";
+            if (!contentChunk) {
+                return;
+            }
+            if (!assistantPrefixPrinted) {
+                output.write(`${style("otto", ANSI.coral, supportsAnsi())} `);
+                assistantPrefixPrinted = true;
+            }
+            output.write(contentChunk);
+            streamedAssistant += contentChunk;
         });
-        const summary = extractResponseSummary(response);
-        if (summary) {
-            console.log(`${style("otto", ANSI.coral, supportsAnsi())} ${summary}`);
-        }
-        conversation.push({ role: "user", content: normalizedPrompt });
-        if (summary) {
-            conversation.push({ role: "assistant", content: summary });
-        }
-        while (conversation.length > 16) {
-            conversation.shift();
+        if (assistantPrefixPrinted) {
+            output.write("\n");
         }
-        const job = response.job && typeof response.job === "object" ? response.job : null;
-        const jobId = normalizeText(job?.id);
-        if (jobId) {
-            const terminalSummary = await followConsoleJob(rl, config, jobId);
-            if (terminalSummary) {
-                conversation.push({ role: "assistant", content: terminalSummary });
+        let finalAssistantSummary = normalizeText(streamedAssistant);
+        if (handoffPayload) {
+            const handoffData = handoffPayload;
+            const bridgeSummary = extractBridgeHandoffSummary(handoffData);
+            if (bridgeSummary) {
+                console.log(`${style("otto", ANSI.coral, supportsAnsi())} ${bridgeSummary}`);
+            }
+            const job = handoffData.job && typeof handoffData.job === "object"
+                ? handoffData.job
+                : null;
+            const jobId = normalizeText(job?.id);
+            if (jobId) {
+                finalAssistantSummary = await followConsoleJob(rl, config, jobId);
+            }
+            else if (bridgeSummary) {
+                finalAssistantSummary = bridgeSummary;
             }
         }
-        else if (normalizeText(response.route_mode) === "cloud_then_execute" || normalizeText(response.route_mode) === "execute_then_cloud") {
-            printWarning("Este fluxo ainda pede continuação cloud fora do console local. Acompanhe o app web se precisar do fechamento completo.");
+        if (finalAssistantSummary) {
+            conversation.push({ role: "assistant", content: finalAssistantSummary });
+            while (conversation.length > 18) {
+                conversation.shift();
+            }
         }
     };
     printConsoleHelp();
-    try {
-        if (options?.initialPrompt) {
-            await handlePrompt(options.initialPrompt);
+    if (options?.initialPrompt) {
+        await handlePrompt(options.initialPrompt);
+    }
+    for (;;) {
+        const promptText = await ask(rl, "OTTO", { allowEmpty: true });
+        try {
+            await handlePrompt(promptText);
         }
-        for (;;) {
-            const promptText = await ask(rl, "OTTO", { allowEmpty: true });
-            try {
-                await handlePrompt(promptText);
-            }
-            catch (error) {
-                if (error instanceof Error && error.message === "__OTTO_CONSOLE_EXIT__") {
-                    break;
-                }
-                throw error;
+        catch (error) {
+            if (error instanceof Error && error.message === "__OTTO_CONSOLE_EXIT__") {
+                break;
             }
+            throw error;
         }
     }
-    finally {
-        await runtime.stop().catch(() => undefined);
-        await runtimeTask.catch(() => undefined);
-    }
 }
-async function printStatusView(rl, config) {
+async function printStatusView(rl, config, runtimeSession) {
     printSection("Bridge Status");
-    renderStatusOverview(config).forEach((line) => console.log(line));
+    renderStatusOverview(config, runtimeSession).forEach((line) => console.log(line));
     await printExtensionsOverview(config);
     await pauseForEnter(rl);
 }
@@ -409,6 +563,7 @@ async function pickHomeChoice(rl, paired) {
 }
 export async function launchInteractiveCli(options) {
     const rl = await createPromptInterface();
+    let runtimeSession = null;
     try {
         console.clear();
         console.log(renderBanner());
@@ -417,16 +572,19 @@ export async function launchInteractiveCli(options) {
             const setup = await runSetupWizard(rl, options);
             config = setup.config;
             if (config && setup.openConsole) {
-                await runOttoConsole(rl, config);
-                return;
+                runtimeSession = new CliRuntimeSession(config);
+                await runtimeSession.ensureStarted();
+                await runOttoConsole(rl, config, runtimeSession);
             }
             if (!config) {
                 return;
             }
         }
+        runtimeSession = runtimeSession || new CliRuntimeSession(config);
+        await runtimeSession.ensureStarted();
         for (;;) {
             console.log("");
-            renderStatusOverview(config).forEach((line) => console.log(line));
+            renderStatusOverview(config, runtimeSession).forEach((line) => console.log(line));
             const choice = await pickHomeChoice(rl, true);
             if (choice === "exit") {
                 break;
@@ -435,18 +593,25 @@ export async function launchInteractiveCli(options) {
                 const setup = await runSetupWizard(rl);
                 if (setup.config) {
                     config = setup.config;
+                    if (runtimeSession) {
+                        await runtimeSession.replaceConfig(setup.config);
+                    }
+                    else {
+                        runtimeSession = new CliRuntimeSession(setup.config);
+                        await runtimeSession.ensureStarted();
+                    }
                 }
-                if (setup.config && setup.openConsole) {
-                    await runOttoConsole(rl, setup.config);
+                if (setup.config && setup.openConsole && runtimeSession) {
+                    await runOttoConsole(rl, setup.config, runtimeSession);
                 }
                 continue;
             }
-            if (choice === "console") {
-                await runOttoConsole(rl, config);
+            if (choice === "console" && runtimeSession) {
+                await runOttoConsole(rl, config, runtimeSession);
                 continue;
             }
-            if (choice === "status") {
-                await printStatusView(rl, config);
+            if (choice === "status" && runtimeSession) {
+                await printStatusView(rl, config, runtimeSession);
                 continue;
             }
             if (choice === "extensions") {
@@ -456,35 +621,48 @@ export async function launchInteractiveCli(options) {
         }
     }
     finally {
+        await runtimeSession?.stop().catch(() => undefined);
         rl.close();
     }
 }
 export async function runSetupCommand(options) {
     const rl = await createPromptInterface();
+    let runtimeSession = null;
     try {
         console.clear();
         console.log(renderBanner());
         const setup = await runSetupWizard(rl, options);
         if (setup.config && setup.openConsole) {
-            await runOttoConsole(rl, setup.config);
+            runtimeSession = new CliRuntimeSession(setup.config);
+            await runtimeSession.ensureStarted();
+            await runOttoConsole(rl, setup.config, runtimeSession);
         }
     }
     finally {
+        await runtimeSession?.stop().catch(() => undefined);
         rl.close();
     }
 }
 export async function runConsoleCommand(initialPrompt) {
-    const config = await loadBridgeConfig();
-    if (!config) {
-        throw new Error("Nenhum pairing local encontrado. Rode `otto-bridge setup` primeiro.");
-    }
     const rl = await createPromptInterface();
+    let runtimeSession = null;
     try {
         console.clear();
         console.log(renderBanner());
-        await runOttoConsole(rl, config, { initialPrompt });
+        let config = await loadBridgeConfig();
+        if (!config) {
+            const setup = await runSetupWizard(rl);
+            if (!setup.config) {
+                return;
+            }
+            config = setup.config;
+        }
+        runtimeSession = new CliRuntimeSession(config);
+        await runtimeSession.ensureStarted();
+        await runOttoConsole(rl, config, runtimeSession, { initialPrompt });
     }
     finally {
+        await runtimeSession?.stop().catch(() => undefined);
         rl.close();
     }
 }

package/dist/local_automations.js

@@ -236,6 +236,7 @@ function isSupportedBridgeAutomation(automation) {
 }
 export class LocalAutomationRuntime {
     config;
+    logger;
     automations = new Map();
     states = new Map();
     syncTimer = null;
@@ -245,8 +246,12 @@ export class LocalAutomationRuntime {
     started = false;
     stopped = false;
     whatsappBrowser = null;
-    constructor(config) {
+    constructor(config, logger) {
         this.config = config;
+        this.logger = logger;
+    }
+    logWarn(message) {
+        (this.logger?.warn || console.warn)(message);
     }
     async start() {
         if (this.started) {
@@ -256,11 +261,11 @@ export class LocalAutomationRuntime {
         this.stopped = false;
         await this.syncAutomations().catch((error) => {
             const detail = error instanceof Error ? error.message : String(error);
-            console.warn(`[otto-bridge] local automations sync failed: ${detail}`);
+            this.logWarn(`[otto-bridge] local automations sync failed: ${detail}`);
         });
         await this.tick().catch((error) => {
             const detail = error instanceof Error ? error.message : String(error);
-            console.warn(`[otto-bridge] local automations tick failed: ${detail}`);
+            this.logWarn(`[otto-bridge] local automations tick failed: ${detail}`);
         });
         this.syncTimer = setInterval(() => {
             void this.syncAutomations();
@@ -332,7 +337,7 @@ export class LocalAutomationRuntime {
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
-            console.warn(`[otto-bridge] local automations sync failed: ${detail}`);
+            this.logWarn(`[otto-bridge] local automations sync failed: ${detail}`);
         }
         finally {
             this.syncInFlight = false;
@@ -368,7 +373,7 @@ export class LocalAutomationRuntime {
                 }
                 catch (error) {
                     const detail = error instanceof Error ? error.message : String(error);
-                    console.warn(`[otto-bridge] local automation failed id=${automationId}: ${detail}`);
+                    this.logWarn(`[otto-bridge] local automation failed id=${automationId}: ${detail}`);
                 }
                 finally {
                     state.running = false;
@@ -401,7 +406,7 @@ export class LocalAutomationRuntime {
         await browser.ensureReady();
         const selected = await browser.selectConversation(contact);
         if (!selected) {
-            console.warn(`[otto-bridge] local whatsapp automation could not find contact="${contact}"`);
+            this.logWarn(`[otto-bridge] local whatsapp automation could not find contact="${contact}"`);
             return;
         }
         await this.processWhatsAppConversation(automation, state, browser, contact, { alreadySelected: true });
@@ -430,7 +435,7 @@ export class LocalAutomationRuntime {
             try {
                 const selected = await browser.selectConversation(contact);
                 if (!selected) {
-                    console.warn(`[otto-bridge] local whatsapp inbox automation could not find contact="${contact}"`);
+                    this.logWarn(`[otto-bridge] local whatsapp inbox automation could not find contact="${contact}"`);
                     continue;
                 }
                 await this.processWhatsAppConversation(automation, state, browser, contact, {
@@ -440,7 +445,7 @@ export class LocalAutomationRuntime {
             }
             catch (error) {
                 const detail = error instanceof Error ? error.message : String(error);
-                console.warn(`[otto-bridge] local whatsapp inbox conversation failed contact="${contact}": ${detail}`);
+                this.logWarn(`[otto-bridge] local whatsapp inbox conversation failed contact="${contact}": ${detail}`);
             }
         }
     }
@@ -495,7 +500,7 @@ export class LocalAutomationRuntime {
         if (!options?.alreadySelected) {
             const selected = await browser.selectConversation(contact);
             if (!selected) {
-                console.warn(`[otto-bridge] local whatsapp automation could not find contact="${contact}"`);
+                this.logWarn(`[otto-bridge] local whatsapp automation could not find contact="${contact}"`);
                 return;
             }
         }
@@ -569,7 +574,7 @@ export class LocalAutomationRuntime {
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
-            console.warn(`[otto-bridge] local whatsapp completion failed id=${automation.id}: ${detail}`);
+            this.logWarn(`[otto-bridge] local whatsapp completion failed id=${automation.id}: ${detail}`);
             this.rememberDeltaHash(automation, state, contact, sent ? completionDeltaHash : deltaHash);
         }
     }

package/dist/main.js

@@ -110,7 +110,6 @@ function printUsage() {
   otto-bridge setup
   otto-bridge console
   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
@@ -126,7 +125,6 @@ Examples:
   otto-bridge setup
   otto-bridge console
   otto-bridge pair --api https://api.leg3ndy.com.br --code ABC123
-  otto-bridge run
   otto-bridge extensions --install whatsappweb
   otto-bridge extensions --setup whatsappweb
   otto-bridge extensions --status whatsappweb
@@ -287,7 +285,7 @@ async function runPairCommand(args) {
     console.log(`[otto-bridge] paired device=${config.deviceId}`);
     console.log(`[otto-bridge] executor=${config.executor.type}`);
     console.log(`[otto-bridge] config=${getBridgeConfigPath()}`);
-    console.log("[otto-bridge] next step: run `otto-bridge run` to keep this device online");
+    console.log("[otto-bridge] next step: run `otto-bridge` to abrir o hub e manter o runtime local online");
 }
 async function loadRequiredBridgeConfig() {
     const config = await loadBridgeConfig();
@@ -297,6 +295,7 @@ async function loadRequiredBridgeConfig() {
     return config;
 }
 async function runRuntimeCommand(args) {
+    console.log("[otto-bridge] `run` agora é um alias legado. Prefira `otto-bridge`.");
     const config = await loadRequiredBridgeConfig();
     const runtimeConfig = {
         ...config,

package/dist/runtime.js

@@ -78,6 +78,7 @@ async function parseSocketMessage(data) {
 }
 export class BridgeRuntime {
     config;
+    options;
     reconnectDelayMs = DEFAULT_RECONNECT_BASE_DELAY_MS;
     executor;
     localAutomationRuntime;
@@ -87,10 +88,23 @@ export class BridgeRuntime {
     started = false;
     pendingConfirmations = new Map();
     activeCancels = new Map();
-    constructor(config, executor) {
+    constructor(config, executor, options = {}) {
         this.config = config;
+        this.options = options;
         this.executor = executor ?? this.createDefaultExecutor(config);
-        this.localAutomationRuntime = new LocalAutomationRuntime(config);
+        this.localAutomationRuntime = new LocalAutomationRuntime(config, this.options.logger);
+    }
+    logInfo(message) {
+        (this.options.logger?.info || console.log)(message);
+    }
+    logWarn(message) {
+        (this.options.logger?.warn || console.warn)(message);
+    }
+    logError(message) {
+        (this.options.logger?.error || console.error)(message);
+    }
+    emit(event) {
+        this.options.logger?.event?.(event);
     }
     async buildHelloMetadata() {
         const metadata = {
@@ -169,10 +183,11 @@ export class BridgeRuntime {
             }
             await this.localAutomationRuntime.start().catch((error) => {
                 const detail = error instanceof Error ? error.message : String(error);
-                console.error(`[otto-bridge] local automation runtime failed to start: ${detail}`);
+                this.logError(`[otto-bridge] local automation runtime failed to start: ${detail}`);
             });
         }
-        console.log(`[otto-bridge] runtime start device=${this.config.deviceId}`);
+        this.logInfo(`[otto-bridge] runtime start device=${this.config.deviceId}`);
+        this.emit({ type: "starting", deviceId: this.config.deviceId });
         while (!this.stopped) {
             try {
                 await this.connectOnce();
@@ -183,12 +198,14 @@ export class BridgeRuntime {
                     break;
                 }
                 const message = error instanceof Error ? error.message : String(error);
-                console.error(`[otto-bridge] socket error: ${message}`);
+                this.logError(`[otto-bridge] socket error: ${message}`);
+                this.emit({ type: "socket_error", message });
             }
             if (this.stopped) {
                 break;
             }
-            console.log(`[otto-bridge] reconnecting in ${this.reconnectDelayMs}ms`);
+            this.logInfo(`[otto-bridge] reconnecting in ${this.reconnectDelayMs}ms`);
+            this.emit({ type: "reconnecting", delayMs: this.reconnectDelayMs });
             await delay(this.reconnectDelayMs);
             this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, DEFAULT_RECONNECT_MAX_DELAY_MS);
         }
@@ -238,10 +255,11 @@ export class BridgeRuntime {
         };
         return await new Promise((resolve, reject) => {
             socket.addEventListener("open", () => {
-                console.log(`[otto-bridge] connected ws=${this.config.wsUrl}`);
+                this.logInfo(`[otto-bridge] connected ws=${this.config.wsUrl}`);
+                this.emit({ type: "connected", wsUrl: this.config.wsUrl });
                 this.sendHello(socket).catch((error) => {
                     const detail = error instanceof Error ? error.message : String(error);
-                    console.error(`[otto-bridge] hello metadata failed: ${detail}`);
+                    this.logError(`[otto-bridge] hello metadata failed: ${detail}`);
                 });
                 heartbeatTimer = setInterval(() => {
                     if (socket.readyState === WebSocket.OPEN) {
@@ -260,14 +278,15 @@ export class BridgeRuntime {
                 }
                 catch (error) {
                     const detail = error instanceof Error ? error.message : String(error);
-                    console.error(`[otto-bridge] invalid message: ${detail}`);
+                    this.logError(`[otto-bridge] invalid message: ${detail}`);
                 }
             });
             socket.addEventListener("close", (event) => {
                 stopHeartbeat();
                 rejectPendingConfirmations(new Error("WebSocket closed while awaiting confirmation"));
                 this.activeSocket = null;
-                console.log(`[otto-bridge] socket closed code=${event.code}`);
+                this.logInfo(`[otto-bridge] socket closed code=${event.code}`);
+                this.emit({ type: "socket_closed", code: event.code });
                 resolve();
             });
             socket.addEventListener("error", () => {
@@ -288,14 +307,16 @@ export class BridgeRuntime {
         const type = String(message.type || "");
         switch (type) {
             case "device.hello":
-                console.log(`[otto-bridge] server hello device=${String(message.device_id || "")}`);
+                this.logInfo(`[otto-bridge] server hello device=${String(message.device_id || "")}`);
+                this.emit({ type: "server_hello", deviceId: String(message.device_id || "") });
                 return;
             case "device.hello_ack":
                 this.maybeLogBridgeReleaseNotice(message);
             case "device.heartbeat_ack":
                 return;
             case "device.job.start":
-                console.log(`[otto-bridge] job start payload=${JSON.stringify(message)}`);
+                this.logInfo(`[otto-bridge] job start payload=${JSON.stringify(message)}`);
+                this.emit({ type: "job_start", jobId: String(message.job_id || "") });
                 this.executeJob(socket, {
                     job_id: String(message.job_id || ""),
                     device_id: String(message.device_id || ""),
@@ -305,7 +326,7 @@ export class BridgeRuntime {
                         : {},
                 }).catch((error) => {
                     const detail = error instanceof Error ? error.message : String(error);
-                    console.error(`[otto-bridge] executor error: ${detail}`);
+                    this.logError(`[otto-bridge] executor error: ${detail}`);
                 });
                 return;
             case "device.job.confirmation":
@@ -315,7 +336,7 @@ export class BridgeRuntime {
                 await this.cancelJob(String(message.job_id || ""), String(message.step_id || ""));
                 return;
             default:
-                console.log(`[otto-bridge] event=${type || "unknown"} payload=${JSON.stringify(message)}`);
+                this.logInfo(`[otto-bridge] event=${type || "unknown"} payload=${JSON.stringify(message)}`);
         }
     }
     maybeLogBridgeReleaseNotice(message) {
@@ -334,11 +355,15 @@ export class BridgeRuntime {
         }
         this.lastBridgeReleaseNoticeKey = noticeKey;
         if (updateRequired) {
-            console.warn(`[otto-bridge] update required current=${this.config.bridgeVersion} min_supported=${minSupportedVersion || "unknown"} latest=${latestVersion || "unknown"} command="${updateCommand}"`);
+            const message = `[otto-bridge] update required current=${this.config.bridgeVersion} min_supported=${minSupportedVersion || "unknown"} latest=${latestVersion || "unknown"} command="${updateCommand}"`;
+            this.logWarn(message);
+            this.emit({ type: "update_required", message });
             return;
         }
         if (updateAvailable) {
-            console.log(`[otto-bridge] update available current=${this.config.bridgeVersion} latest=${latestVersion || "unknown"} command="${updateCommand}"`);
+            const message = `[otto-bridge] update available current=${this.config.bridgeVersion} latest=${latestVersion || "unknown"} command="${updateCommand}"`;
+            this.logInfo(message);
+            this.emit({ type: "update_available", message });
         }
     }
     clearPendingConfirmations(jobId) {
@@ -382,7 +407,7 @@ export class BridgeRuntime {
         const waiter = this.pendingConfirmations.get(confirmationKey(jobId, stepId))
             || this.pendingConfirmations.get(jobId);
         if (!jobId || !waiter) {
-            console.warn(`[otto-bridge] unexpected confirmation payload=${JSON.stringify(message)}`);
+            this.logWarn(`[otto-bridge] unexpected confirmation payload=${JSON.stringify(message)}`);
             return;
         }
         if (action !== "approve" && action !== "reject") {
@@ -408,16 +433,16 @@ export class BridgeRuntime {
             return;
         }
         if (this.resolvePendingCancellation(jobId, stepId)) {
-            console.log(`[otto-bridge] confirmation cancelled job=${jobId}${stepId ? ` step=${stepId}` : ""}`);
+            this.logInfo(`[otto-bridge] confirmation cancelled job=${jobId}${stepId ? ` step=${stepId}` : ""}`);
             return;
         }
         const cancel = this.activeCancels.get(jobId);
         if (!cancel) {
-            console.warn(`[otto-bridge] cancel requested for unknown job=${jobId}`);
+            this.logWarn(`[otto-bridge] cancel requested for unknown job=${jobId}`);
             return;
         }
         if (stepId) {
-            console.log(`[otto-bridge] cancel requested job=${jobId} step=${stepId}`);
+            this.logInfo(`[otto-bridge] cancel requested job=${jobId} step=${stepId}`);
         }
         await cancel();
     }
@@ -441,7 +466,8 @@ export class BridgeRuntime {
             if (typeof this.executor.cancel === "function") {
                 await this.executor.cancel(job.job_id);
             }
-            console.log(`[otto-bridge] job cancelled job_id=${job.job_id}`);
+            this.logInfo(`[otto-bridge] job cancelled job_id=${job.job_id}`);
+            this.emit({ type: "job_cancelled", jobId: job.job_id });
         });
         try {
             await this.executor.run(job, {

package/dist/types.js

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

package/scripts/postinstall.mjs

@@ -24,7 +24,7 @@ if (!existsSync(mainPath)) {
   process.exit(0);
 }
 
-console.log("\n[otto-bridge] Welcome to OTTOAI 1.0.0");
+console.log("\n[otto-bridge] Welcome to OTTOAI 1.0.1");
 console.log("[otto-bridge] Vamos iniciar o setup interativo do bridge.\n");
 
 const result = spawnSync(process.execPath, [mainPath, "setup", "--postinstall"], {