@leg3ndy/otto-bridge 0.1.0 → 0.1.2

package/README.md

@@ -7,6 +7,10 @@ Companion local do Otto para:
 - manter um WebSocket persistente com o backend
 - executar jobs locais com `mock` ou `clawd-cursor`
 
+## Guia de uso
+
+Para um passo a passo de instalacao, pareamento, uso, desconexao e desinstalacao, veja [USER_GUIDE.md](https://github.com/LGCYYL/ottoai/blob/main/otto-bridge/USER_GUIDE.md).
+
 ## Distribuicao
 
 Fluxo recomendado agora:
@@ -20,13 +24,14 @@ O pacote ja esta estruturado para install via CLI:
 ```bash
 npm install -g @leg3ndy/otto-bridge
 otto-bridge status
+otto-bridge version
 ```
 
 Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./otto-bridge-0.1.0.tgz
+npm install -g ./leg3ndy-otto-bridge-0.1.2.tgz
 ```
 
 ## Publicacao
@@ -51,6 +56,13 @@ npm_config_cache=/tmp/otto-npm-cache npm publish --access public
 
 ## Comandos
 
+### Listar ajuda
+
+```bash
+otto-bridge help
+otto-bridge --help
+```
+
 ### Parear o dispositivo
 
 ```bash
@@ -80,6 +92,33 @@ Se o executor estiver salvo no `config.json`, o `run` usa essa configuracao por
 otto-bridge status
 ```
 
+### Ver versao instalada
+
+```bash
+otto-bridge version
+otto-bridge --version
+```
+
+### Atualizar o pacote
+
+Atualizacao automatica via npm:
+
+```bash
+otto-bridge update
+```
+
+Para apenas ver qual comando sera executado:
+
+```bash
+otto-bridge update --dry-run
+```
+
+Para instalar manualmente:
+
+```bash
+npm install -g @leg3ndy/otto-bridge@latest
+```
+
 ### Remover pareamento local
 
 ```bash

package/dist/executors/clawd_cursor.js

@@ -1,5 +1,6 @@
 import { setTimeout as sleep } from "node:timers/promises";
 import { getJson, postJson } from "../http.js";
+import { JobCancelledError } from "./shared.js";
 const LOG_LIMIT = 200;
 const COMPLETION_SETTLE_TIMEOUT_MS = 4000;
 const COMPLETION_SETTLE_INTERVAL_MS = 500;
@@ -99,6 +100,7 @@ function stateStatus(state) {
 }
 export class ClawdCursorJobExecutor {
     config;
+    cancelledJobs = new Set();
     constructor(config) {
         this.config = config;
     }
@@ -109,7 +111,13 @@ export class ClawdCursorJobExecutor {
         let lastProgressKey = "";
         let lastProgressPercent = 0;
         let sawActiveState = false;
+        const assertNotCancelled = () => {
+            if (this.cancelledJobs.has(job.job_id)) {
+                throw new JobCancelledError(job.job_id);
+            }
+        };
         try {
+            assertNotCancelled();
             await this.assertHealthy();
             const taskResponse = await postJson(this.config.baseUrl, "/task", { task });
             if (taskResponse.ok !== true) {
@@ -119,6 +127,7 @@ export class ClawdCursorJobExecutor {
             const taskId = asString(taskResponse.task_id) || "";
             await reporter.accepted();
             while (true) {
+                assertNotCancelled();
                 const statusResponse = await getJson(this.config.baseUrl, "/status");
                 const state = asRecord(statusResponse.state);
                 const status = stateStatus(state);
@@ -176,11 +185,18 @@ export class ClawdCursorJobExecutor {
             }
         }
         catch (error) {
-            if (taskAccepted) {
+            if (taskAccepted && !(error instanceof JobCancelledError)) {
                 await this.abortSilently();
             }
             throw error;
         }
+        finally {
+            this.cancelledJobs.delete(job.job_id);
+        }
+    }
+    async cancel(jobId) {
+        this.cancelledJobs.add(jobId);
+        await this.abortSilently();
     }
     async assertHealthy() {
         const health = await getJson(this.config.baseUrl, "/health");

package/dist/executors/mock.js

@@ -1,33 +1,52 @@
 import { setTimeout as sleep } from "node:timers/promises";
+import { JobCancelledError } from "./shared.js";
+const cancelledJobs = new Set();
 function shouldRequireConfirmation(payload) {
     return payload.require_confirmation === true || payload.requireConfirmation === true;
 }
 export class MockJobExecutor {
     async run(job, reporter) {
-        await reporter.accepted();
-        await reporter.progress(15, "Planejando execução local");
-        await sleep(150);
-        if (shouldRequireConfirmation(job.payload)) {
-            const decision = await reporter.confirmRequired("Aguardando confirmação do usuário para continuar a execução mock", {
-                step: "mock_confirmation_gate",
+        const assertNotCancelled = () => {
+            if (cancelledJobs.has(job.job_id)) {
+                throw new JobCancelledError(job.job_id);
+            }
+        };
+        try {
+            assertNotCancelled();
+            await reporter.accepted();
+            await reporter.progress(15, "Planejando execução local");
+            await sleep(150);
+            assertNotCancelled();
+            if (shouldRequireConfirmation(job.payload)) {
+                const decision = await reporter.confirmRequired("Aguardando confirmação do usuário para continuar a execução mock", {
+                    step: "mock_confirmation_gate",
+                    job_type: job.job_type,
+                    payload_preview: job.payload,
+                });
+                if (decision.action === "reject") {
+                    return;
+                }
+                await reporter.progress(55, "Confirmação recebida. Retomando execução mock");
+            }
+            else {
+                await reporter.progress(55, "Executando ação mock no dispositivo");
+            }
+            await sleep(150);
+            assertNotCancelled();
+            await reporter.progress(90, "Finalizando resultado");
+            await sleep(100);
+            assertNotCancelled();
+            await reporter.completed({
+                summary: "Mock executor finished successfully",
                 job_type: job.job_type,
-                payload_preview: job.payload,
+                echoed_payload: job.payload,
             });
-            if (decision.action === "reject") {
-                return;
-            }
-            await reporter.progress(55, "Confirmação recebida. Retomando execução mock");
         }
-        else {
-            await reporter.progress(55, "Executando ação mock no dispositivo");
+        finally {
+            cancelledJobs.delete(job.job_id);
         }
-        await sleep(150);
-        await reporter.progress(90, "Finalizando resultado");
-        await sleep(100);
-        await reporter.completed({
-            summary: "Mock executor finished successfully",
-            job_type: job.job_type,
-            echoed_payload: job.payload,
-        });
+    }
+    async cancel(jobId) {
+        cancelledJobs.add(jobId);
     }
 }

package/dist/executors/shared.js

@@ -0,0 +1,6 @@
+export class JobCancelledError extends Error {
+    constructor(jobId) {
+        super(`Job cancelled: ${jobId}`);
+        this.name = "JobCancelledError";
+    }
+}

package/dist/main.js

@@ -1,11 +1,18 @@
 #!/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 { pairDevice } from "./pairing.js";
 import { BridgeRuntime } from "./runtime.js";
-import { DEFAULT_PAIR_TIMEOUT_SECONDS, DEFAULT_POLL_INTERVAL_MS, } from "./types.js";
+import { BRIDGE_PACKAGE_NAME, BRIDGE_VERSION, DEFAULT_PAIR_TIMEOUT_SECONDS, DEFAULT_POLL_INTERVAL_MS, } from "./types.js";
 function parseArgs(argv) {
     const [maybeCommand, ...rest] = argv;
+    if (maybeCommand === "--help" || maybeCommand === "-h") {
+        return { command: "help", options: new Map() };
+    }
+    if (maybeCommand === "--version" || maybeCommand === "-v") {
+        return { command: "version", options: new Map() };
+    }
     const command = maybeCommand && !maybeCommand.startsWith("--") ? maybeCommand : "run";
     const tokens = command === "run" && maybeCommand?.startsWith("--") ? argv : rest;
     const options = new Map();
@@ -49,7 +56,38 @@ function printUsage() {
   otto-bridge pair --api http://localhost:8000 --code ABC123 [--name "Meu PC"] [--executor mock|clawd-cursor]
   otto-bridge run [--executor mock|clawd-cursor] [--clawd-url http://127.0.0.1:3847]
   otto-bridge status
-  otto-bridge unpair`);
+  otto-bridge version
+  otto-bridge update [--tag latest|next] [--dry-run]
+  otto-bridge unpair
+
+Examples:
+  otto-bridge pair --api https://api.leg3ndy.com.br --code ABC123 --executor clawd-cursor --clawd-url http://127.0.0.1:3847
+  otto-bridge run
+  otto-bridge version
+  otto-bridge update
+  otto-bridge update --dry-run
+  otto-bridge --version`);
+}
+function printVersion() {
+    console.log(`${BRIDGE_PACKAGE_NAME} ${BRIDGE_VERSION}`);
+}
+function runChildCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: "inherit",
+            env: process.env,
+        });
+        child.on("error", (error) => {
+            reject(error);
+        });
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${command} exited with code ${code ?? "unknown"}`));
+        });
+    });
 }
 async function runPairCommand(args) {
     const code = option(args, "code");
@@ -68,6 +106,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");
 }
 async function runRuntimeCommand(args) {
     const config = await loadBridgeConfig();
@@ -105,6 +144,23 @@ async function runUnpairCommand() {
     await clearBridgeConfig();
     console.log("[otto-bridge] local pairing cleared");
 }
+async function runUpdateCommand(args) {
+    const tag = option(args, "tag") || "latest";
+    const packageSpec = `${BRIDGE_PACKAGE_NAME}@${tag}`;
+    const command = process.platform === "win32" ? "npm.cmd" : "npm";
+    const commandArgs = ["install", "-g", packageSpec];
+    const commandString = `${command} ${commandArgs.join(" ")}`;
+    if (args.options.has("dry-run") || args.options.has("check")) {
+        console.log(`[otto-bridge] current=${BRIDGE_VERSION}`);
+        console.log(`[otto-bridge] update command: ${commandString}`);
+        return;
+    }
+    console.log(`[otto-bridge] current=${BRIDGE_VERSION}`);
+    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");
+}
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     switch (args.command) {
@@ -117,6 +173,16 @@ async function main() {
         case "status":
             await runStatusCommand();
             return;
+        case "version":
+            printVersion();
+            return;
+        case "--version":
+        case "-v":
+            printVersion();
+            return;
+        case "update":
+            await runUpdateCommand(args);
+            return;
         case "unpair":
             await runUnpairCommand();
             return;

package/dist/runtime.js

@@ -1,6 +1,7 @@
 import { DEFAULT_HEARTBEAT_INTERVAL_MS, DEFAULT_RECONNECT_BASE_DELAY_MS, DEFAULT_RECONNECT_MAX_DELAY_MS, } from "./types.js";
 import { ClawdCursorJobExecutor } from "./executors/clawd_cursor.js";
 import { MockJobExecutor } from "./executors/mock.js";
+import { JobCancelledError } from "./executors/shared.js";
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -24,6 +25,7 @@ export class BridgeRuntime {
     reconnectDelayMs = DEFAULT_RECONNECT_BASE_DELAY_MS;
     executor;
     pendingConfirmations = new Map();
+    activeCancels = new Map();
     constructor(config, executor) {
         this.config = config;
         this.executor = executor ?? this.createDefaultExecutor(config);
@@ -135,6 +137,9 @@ export class BridgeRuntime {
             case "device.job.confirmation":
                 this.resolveConfirmation(message);
                 return;
+            case "device.job.cancel":
+                await this.cancelJob(String(message.job_id || ""));
+                return;
             default:
                 console.log(`[otto-bridge] event=${type || "unknown"} payload=${JSON.stringify(message)}`);
         }
@@ -163,6 +168,17 @@ export class BridgeRuntime {
             this.pendingConfirmations.set(jobId, { resolve, reject });
         });
     }
+    async cancelJob(jobId) {
+        if (!jobId) {
+            return;
+        }
+        const cancel = this.activeCancels.get(jobId);
+        if (!cancel) {
+            console.warn(`[otto-bridge] cancel requested for unknown job=${jobId}`);
+            return;
+        }
+        await cancel();
+    }
     async executeJob(socket, job) {
         const sendJson = async (payload) => {
             if (socket.readyState !== WebSocket.OPEN) {
@@ -170,6 +186,13 @@ export class BridgeRuntime {
             }
             socket.send(JSON.stringify(payload));
         };
+        this.activeCancels.set(job.job_id, async () => {
+            this.pendingConfirmations.delete(job.job_id);
+            if (typeof this.executor.cancel === "function") {
+                await this.executor.cancel(job.job_id);
+            }
+            console.log(`[otto-bridge] job cancelled job_id=${job.job_id}`);
+        });
         try {
             await this.executor.run(job, {
                 accepted: async () => {
@@ -227,6 +250,9 @@ export class BridgeRuntime {
         }
         catch (error) {
             this.pendingConfirmations.delete(job.job_id);
+            if (error instanceof JobCancelledError) {
+                return;
+            }
             const detail = error instanceof Error ? error.message : String(error);
             try {
                 await sendJson({
@@ -244,6 +270,9 @@ export class BridgeRuntime {
             }
             throw error;
         }
+        finally {
+            this.activeCancels.delete(job.job_id);
+        }
     }
     createDefaultExecutor(config) {
         if (config.executor.type === "clawd-cursor") {

package/dist/types.js

@@ -1,5 +1,6 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "0.1.0";
+export const BRIDGE_VERSION = "0.1.2";
+export const BRIDGE_PACKAGE_NAME = "@leg3ndy/otto-bridge";
 export const DEFAULT_API_BASE_URL = "http://localhost:8000";
 export const DEFAULT_POLL_INTERVAL_MS = 3000;
 export const DEFAULT_PAIR_TIMEOUT_SECONDS = 600;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leg3ndy/otto-bridge",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",
@@ -38,6 +38,8 @@
     "pair": "node dist/main.js pair",
     "run": "node dist/main.js run",
     "status": "node dist/main.js status",
+    "version:cli": "node dist/main.js version",
+    "update:cli": "node dist/main.js update --dry-run",
     "unpair": "node dist/main.js unpair"
   },
   "publishConfig": {