@leg3ndy/otto-bridge 0.1.0

package/README.md

@@ -0,0 +1,117 @@
+# Otto Bridge
+
+Companion local do Otto para:
+
+- reivindicar um codigo de pareamento gerado pela web
+- armazenar o `device_token` do dispositivo
+- manter um WebSocket persistente com o backend
+- executar jobs locais com `mock` ou `clawd-cursor`
+
+## Distribuicao
+
+Fluxo recomendado agora:
+
+1. publicar como pacote npm privado/publico para time interno e beta testers
+2. validar pareamento, atualizacao e telemetria em ambiente real
+3. depois empacotar em `.dmg/.pkg` no macOS e `.msi` no Windows
+
+O pacote ja esta estruturado para install via CLI:
+
+```bash
+npm install -g @leg3ndy/otto-bridge
+otto-bridge status
+```
+
+Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
+
+```bash
+npm pack
+npm install -g ./otto-bridge-0.1.0.tgz
+```
+
+## Publicacao
+
+Checklist de release:
+
+```bash
+npm whoami
+npm install
+npm run release:check
+npm publish --access public
+```
+
+O publish exige permissao no scope `@leg3ndy`.
+
+Se o seu `npm` local estiver com cache travado por permissao, rode com cache temporario:
+
+```bash
+npm_config_cache=/tmp/otto-npm-cache npm run release:check
+npm_config_cache=/tmp/otto-npm-cache npm publish --access public
+```
+
+## Comandos
+
+### Parear o dispositivo
+
+```bash
+otto-bridge pair --api http://localhost:8000 --code ABC123 --executor clawd-cursor
+```
+
+Opcoes suportadas:
+
+- `--name`: nome amigavel do dispositivo
+- `--timeout-seconds`: limite de espera pela aprovacao web
+- `--poll-interval-ms`: intervalo de polling do claim
+- `--executor`: `mock` ou `clawd-cursor`
+- `--clawd-url`: base URL da API local do `clawd-cursor`
+- `--clawd-poll-interval-ms`: polling do status/logs do `clawd-cursor`
+
+### Rodar o bridge
+
+```bash
+otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
+```
+
+Se o executor estiver salvo no `config.json`, o `run` usa essa configuracao por padrao.
+
+### Ver estado local
+
+```bash
+otto-bridge status
+```
+
+### Remover pareamento local
+
+```bash
+otto-bridge unpair
+```
+
+## Variaveis de ambiente
+
+- `OTTO_API_BASE_URL`
+- `OTTO_BRIDGE_HOME`
+- `OTTO_BRIDGE_NAME`
+- `OTTO_BRIDGE_EXECUTOR`
+- `OTTO_CLAWD_BASE_URL`
+- `OTTO_CLAWD_POLL_INTERVAL_MS`
+
+## Payload esperado para jobs desktop
+
+O adapter do `clawd-cursor` procura a tarefa em uma destas chaves, nessa ordem:
+
+- `task`
+- `prompt`
+- `instruction`
+- `instructions`
+- `message`
+
+Exemplo:
+
+```json
+{
+  "job_type": "desktop_task",
+  "payload": {
+    "task": "Abra o Safari e pesquise Otto AI"
+  }
+}
+```

package/dist/config.js

@@ -0,0 +1,131 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, hostname, platform, arch } from "node:os";
+import path from "node:path";
+import { BRIDGE_CONFIG_VERSION, BRIDGE_VERSION, DEFAULT_CLAWD_CURSOR_BASE_URL, DEFAULT_CLAWD_CURSOR_POLL_INTERVAL_MS, DEFAULT_API_BASE_URL, DEFAULT_EXECUTOR_TYPE, } from "./types.js";
+function sanitizeApiBaseUrl(value) {
+    const raw = String(value || DEFAULT_API_BASE_URL).trim();
+    if (!raw) {
+        return DEFAULT_API_BASE_URL;
+    }
+    return raw.replace(/\/+$/, "");
+}
+function sanitizeExecutorType(value) {
+    return value === "clawd-cursor" ? "clawd-cursor" : DEFAULT_EXECUTOR_TYPE;
+}
+function sanitizeClawdCursorBaseUrl(value) {
+    const raw = String(value || DEFAULT_CLAWD_CURSOR_BASE_URL).trim();
+    if (!raw) {
+        return DEFAULT_CLAWD_CURSOR_BASE_URL;
+    }
+    return raw.replace(/\/+$/, "");
+}
+function sanitizePollIntervalMs(value, fallback = DEFAULT_CLAWD_CURSOR_POLL_INTERVAL_MS) {
+    const parsed = Number(value ?? fallback);
+    if (!Number.isFinite(parsed)) {
+        return fallback;
+    }
+    return Math.max(250, Math.floor(parsed));
+}
+export function getBridgeHomeDir() {
+    const custom = String(process.env.OTTO_BRIDGE_HOME || "").trim();
+    return custom || path.join(homedir(), ".otto-bridge");
+}
+export function getBridgeConfigPath() {
+    return path.join(getBridgeHomeDir(), "config.json");
+}
+export async function ensureBridgeHomeDir() {
+    await mkdir(getBridgeHomeDir(), { recursive: true });
+}
+export async function loadBridgeConfig() {
+    try {
+        const raw = await readFile(getBridgeConfigPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        if (!parsed.deviceToken || !parsed.deviceId) {
+            return null;
+        }
+        return {
+            ...parsed,
+            apiBaseUrl: sanitizeApiBaseUrl(parsed.apiBaseUrl),
+            wsUrl: buildWebSocketUrl(parsed.apiBaseUrl),
+            executor: resolveExecutorConfig(undefined, parsed.executor),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveBridgeConfig(config) {
+    await ensureBridgeHomeDir();
+    await writeFile(getBridgeConfigPath(), `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+export async function clearBridgeConfig() {
+    await rm(getBridgeConfigPath(), { force: true });
+}
+export function resolveApiBaseUrl(explicit) {
+    return sanitizeApiBaseUrl(explicit || process.env.OTTO_API_BASE_URL || DEFAULT_API_BASE_URL);
+}
+export function resolveExecutorConfig(overrides, current) {
+    const currentType = sanitizeExecutorType(current?.type);
+    const type = sanitizeExecutorType(overrides?.type ?? currentType ?? process.env.OTTO_BRIDGE_EXECUTOR);
+    if (type === "clawd-cursor") {
+        const currentClawd = current?.type === "clawd-cursor" ? current : null;
+        return {
+            type: "clawd-cursor",
+            baseUrl: sanitizeClawdCursorBaseUrl(overrides?.clawdBaseUrl
+                ?? currentClawd?.baseUrl
+                ?? process.env.OTTO_CLAWD_BASE_URL),
+            pollIntervalMs: sanitizePollIntervalMs(overrides?.clawdPollIntervalMs
+                ?? currentClawd?.pollIntervalMs
+                ?? process.env.OTTO_CLAWD_POLL_INTERVAL_MS),
+        };
+    }
+    return { type: "mock" };
+}
+export function buildWebSocketUrl(apiBaseUrl) {
+    const url = new URL(resolveApiBaseUrl(apiBaseUrl));
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.pathname = "/v1/devices/ws";
+    url.search = "";
+    return url.toString();
+}
+export function defaultDeviceName() {
+    const envName = String(process.env.OTTO_BRIDGE_NAME || "").trim();
+    if (envName) {
+        return envName;
+    }
+    return `Otto Bridge - ${hostname()}`;
+}
+export function buildDeviceMetadata() {
+    return {
+        host: hostname(),
+        arch: arch(),
+        node: process.version,
+        runtime: "node",
+    };
+}
+export function buildDeviceFingerprint() {
+    const input = `${hostname()}|${platform()}|${arch()}|${process.version}`;
+    return createHash("sha256").update(input).digest("hex");
+}
+export function buildBridgeConfig(params) {
+    const apiBaseUrl = resolveApiBaseUrl(params.apiBaseUrl);
+    return {
+        version: BRIDGE_CONFIG_VERSION,
+        apiBaseUrl,
+        wsUrl: buildWebSocketUrl(apiBaseUrl),
+        deviceId: params.deviceId,
+        deviceToken: params.deviceToken,
+        deviceName: params.deviceName,
+        platform: platform(),
+        bridgeVersion: BRIDGE_VERSION,
+        approvalMode: params.approvalMode || "preview",
+        capabilities: Array.isArray(params.capabilities) ? [...params.capabilities] : [],
+        metadata: params.metadata || {},
+        pairedAt: new Date().toISOString(),
+        executor: resolveExecutorConfig(undefined, params.executor),
+    };
+}

package/dist/executors/base.js

@@ -0,0 +1 @@
+export {};

package/dist/executors/clawd_cursor.js

@@ -0,0 +1,236 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { getJson, postJson } from "../http.js";
+const LOG_LIMIT = 200;
+const COMPLETION_SETTLE_TIMEOUT_MS = 4000;
+const COMPLETION_SETTLE_INTERVAL_MS = 500;
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function asString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+function asNumber(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        return null;
+    }
+    return parsed;
+}
+function clampPercent(value) {
+    return Math.max(0, Math.min(100, Math.round(value)));
+}
+function extractTaskText(job) {
+    const payload = asRecord(job.payload);
+    const candidates = [
+        payload.task,
+        payload.prompt,
+        payload.instruction,
+        payload.instructions,
+        payload.message,
+    ];
+    for (const candidate of candidates) {
+        const text = asString(candidate);
+        if (text) {
+            return text;
+        }
+    }
+    const serializedPayload = JSON.stringify(payload);
+    if (serializedPayload && serializedPayload !== "{}") {
+        return `Execute Otto job ${job.job_type} with payload: ${serializedPayload}`;
+    }
+    return `Execute Otto job ${job.job_type}`;
+}
+function parseLogTimestamp(entry) {
+    const timestamp = asString(entry.timestamp);
+    if (!timestamp) {
+        return 0;
+    }
+    const parsed = Date.parse(timestamp);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function filterLogsSince(logs, startedAtMs) {
+    return logs.filter((entry) => parseLogTimestamp(entry) >= startedAtMs - 1000);
+}
+function summarizeLog(entry, fallback) {
+    const message = asString(entry?.message);
+    if (!message) {
+        return fallback;
+    }
+    return message.length > 240 ? `${message.slice(0, 237)}...` : message;
+}
+function buildStatusMessage(state, fallbackTask) {
+    const currentStep = asString(state.currentStep);
+    if (currentStep) {
+        return currentStep;
+    }
+    const currentTask = asString(state.currentTask);
+    if (currentTask) {
+        return currentTask;
+    }
+    const status = asString(state.status);
+    if (status && status !== "idle") {
+        return `Executor status: ${status}`;
+    }
+    return fallbackTask;
+}
+function buildProgressPercent(state, fallbackStatus, lastProgressPercent) {
+    const stepsCompleted = asNumber(state.stepsCompleted);
+    const stepsTotal = asNumber(state.stepsTotal);
+    if (stepsCompleted !== null && stepsTotal !== null && stepsTotal > 0) {
+        return clampPercent(Math.max(lastProgressPercent, (stepsCompleted / stepsTotal) * 100));
+    }
+    switch (fallbackStatus) {
+        case "thinking":
+            return Math.max(lastProgressPercent, 15);
+        case "acting":
+            return Math.max(lastProgressPercent, 55);
+        case "waiting_confirm":
+            return Math.max(lastProgressPercent, 75);
+        default:
+            return lastProgressPercent;
+    }
+}
+function stateStatus(state) {
+    return String(state.status || "").trim().toLowerCase();
+}
+export class ClawdCursorJobExecutor {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async run(job, reporter) {
+        const task = extractTaskText(job);
+        const startedAtMs = Date.now();
+        let taskAccepted = false;
+        let lastProgressKey = "";
+        let lastProgressPercent = 0;
+        let sawActiveState = false;
+        try {
+            await this.assertHealthy();
+            const taskResponse = await postJson(this.config.baseUrl, "/task", { task });
+            if (taskResponse.ok !== true) {
+                throw new Error("Clawd Cursor rejected task execution");
+            }
+            taskAccepted = true;
+            const taskId = asString(taskResponse.task_id) || "";
+            await reporter.accepted();
+            while (true) {
+                const statusResponse = await getJson(this.config.baseUrl, "/status");
+                const state = asRecord(statusResponse.state);
+                const status = stateStatus(state);
+                const progressMessage = buildStatusMessage(state, task);
+                const progressPercent = buildProgressPercent(state, status, lastProgressPercent);
+                if (status && status !== "idle") {
+                    sawActiveState = true;
+                }
+                if (status === "waiting_confirm") {
+                    const decision = await reporter.confirmRequired(progressMessage, {
+                        executor: "clawd-cursor",
+                        task_id: taskId,
+                        task,
+                        state,
+                    });
+                    await postJson(this.config.baseUrl, "/confirm", {
+                        approved: decision.action === "approve",
+                    });
+                    if (decision.action === "reject") {
+                        return;
+                    }
+                    await sleep(this.config.pollIntervalMs);
+                    continue;
+                }
+                if (status !== "idle") {
+                    const progressKey = `${status}:${progressPercent}:${progressMessage}`;
+                    if (progressKey !== lastProgressKey) {
+                        await reporter.progress(progressPercent, progressMessage);
+                        lastProgressKey = progressKey;
+                        lastProgressPercent = progressPercent;
+                    }
+                    await sleep(this.config.pollIntervalMs);
+                    continue;
+                }
+                if (!sawActiveState) {
+                    await sleep(this.config.pollIntervalMs);
+                    continue;
+                }
+                const outcome = await this.resolveOutcome(startedAtMs);
+                if (!outcome.ok) {
+                    await reporter.failed(outcome.summary, {
+                        executor: "clawd-cursor",
+                        task_id: taskId,
+                        logs: outcome.logs,
+                    });
+                    return;
+                }
+                await reporter.completed({
+                    summary: outcome.summary,
+                    executor: "clawd-cursor",
+                    task_id: taskId,
+                    logs: outcome.logs,
+                });
+                return;
+            }
+        }
+        catch (error) {
+            if (taskAccepted) {
+                await this.abortSilently();
+            }
+            throw error;
+        }
+    }
+    async assertHealthy() {
+        const health = await getJson(this.config.baseUrl, "/health");
+        if (health.ok !== true) {
+            throw new Error("Clawd Cursor health check failed");
+        }
+    }
+    async resolveOutcome(startedAtMs) {
+        const deadline = Date.now() + COMPLETION_SETTLE_TIMEOUT_MS;
+        let recentLogs = [];
+        while (Date.now() <= deadline) {
+            const logsResponse = await getJson(this.config.baseUrl, `/logs?limit=${LOG_LIMIT}`);
+            const allLogs = Array.isArray(logsResponse.logs) ? logsResponse.logs : [];
+            recentLogs = filterLogsSince(allLogs, startedAtMs);
+            const failureLog = [...recentLogs].reverse().find((entry) => {
+                const message = asString(entry.message)?.toLowerCase() || "";
+                return message.includes("task execution failed");
+            }) || null;
+            if (failureLog) {
+                return {
+                    ok: false,
+                    summary: summarizeLog(failureLog, "Clawd Cursor task failed"),
+                    logs: recentLogs.slice(-10),
+                };
+            }
+            const successLog = [...recentLogs].reverse().find((entry) => {
+                const message = asString(entry.message)?.toLowerCase() || "";
+                return message.includes("task result:");
+            }) || null;
+            if (successLog) {
+                return {
+                    ok: true,
+                    summary: summarizeLog(successLog, "Clawd Cursor task completed"),
+                    logs: recentLogs.slice(-10),
+                };
+            }
+            await sleep(COMPLETION_SETTLE_INTERVAL_MS);
+        }
+        return {
+            ok: true,
+            summary: "Clawd Cursor task completed",
+            logs: recentLogs.slice(-10),
+        };
+    }
+    async abortSilently() {
+        try {
+            await postJson(this.config.baseUrl, "/abort", {});
+        }
+        catch {
+            // Best effort only. The Otto backend still receives the executor failure.
+        }
+    }
+}

package/dist/executors/mock.js

@@ -0,0 +1,33 @@
+import { setTimeout as sleep } from "node:timers/promises";
+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",
+                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);
+        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,
+        });
+    }
+}

package/dist/http.js

@@ -0,0 +1,32 @@
+import { DEFAULT_API_BASE_URL } from "./types.js";
+function normalizeBaseUrl(apiBaseUrl) {
+    const raw = String(apiBaseUrl || DEFAULT_API_BASE_URL).trim();
+    return raw.replace(/\/+$/, "");
+}
+async function requestJson(apiBaseUrl, pathname, init) {
+    const response = await fetch(`${normalizeBaseUrl(apiBaseUrl)}${pathname}`, init);
+    const payload = (await response.json().catch(() => null));
+    if (!response.ok) {
+        const detail = payload && typeof payload === "object" && payload !== null
+            ? (("detail" in payload && typeof payload.detail === "string" && payload.detail)
+                || ("error" in payload && typeof payload.error === "string" && payload.error))
+            : null;
+        throw new Error(detail || `HTTP ${response.status}`);
+    }
+    if (!payload) {
+        throw new Error("Empty JSON response");
+    }
+    return payload;
+}
+export async function getJson(apiBaseUrl, pathname) {
+    return await requestJson(apiBaseUrl, pathname);
+}
+export async function postJson(apiBaseUrl, pathname, body) {
+    return await requestJson(apiBaseUrl, pathname, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+}

package/dist/main.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+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";
+function parseArgs(argv) {
+    const [maybeCommand, ...rest] = argv;
+    const command = maybeCommand && !maybeCommand.startsWith("--") ? maybeCommand : "run";
+    const tokens = command === "run" && maybeCommand?.startsWith("--") ? argv : rest;
+    const options = new Map();
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if (!token.startsWith("--")) {
+            continue;
+        }
+        const key = token.slice(2);
+        const next = tokens[i + 1];
+        if (!next || next.startsWith("--")) {
+            options.set(key, true);
+            continue;
+        }
+        options.set(key, next);
+        i += 1;
+    }
+    return { command, options };
+}
+function option(args, name) {
+    const value = args.options.get(name);
+    return typeof value === "string" ? value : undefined;
+}
+function numberOption(args, name) {
+    const value = option(args, name);
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function resolveExecutorOverrides(args, current) {
+    return resolveExecutorConfig({
+        type: option(args, "executor") || process.env.OTTO_BRIDGE_EXECUTOR,
+        clawdBaseUrl: option(args, "clawd-url") || process.env.OTTO_CLAWD_BASE_URL,
+        clawdPollIntervalMs: numberOption(args, "clawd-poll-interval-ms") ?? process.env.OTTO_CLAWD_POLL_INTERVAL_MS,
+    }, current);
+}
+function printUsage() {
+    console.log(`Usage:
+  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`);
+}
+async function runPairCommand(args) {
+    const code = option(args, "code");
+    if (!code) {
+        throw new Error("Missing required --code for pair command");
+    }
+    const apiBaseUrl = resolveApiBaseUrl(option(args, "api"));
+    const config = await pairDevice({
+        apiBaseUrl,
+        pairingCode: code,
+        deviceName: option(args, "name"),
+        timeoutSeconds: Number(option(args, "timeout-seconds") || DEFAULT_PAIR_TIMEOUT_SECONDS),
+        pollIntervalMs: Number(option(args, "poll-interval-ms") || DEFAULT_POLL_INTERVAL_MS),
+        executor: resolveExecutorOverrides(args),
+    });
+    console.log(`[otto-bridge] paired device=${config.deviceId}`);
+    console.log(`[otto-bridge] executor=${config.executor.type}`);
+    console.log(`[otto-bridge] config=${getBridgeConfigPath()}`);
+}
+async function runRuntimeCommand(args) {
+    const config = await loadBridgeConfig();
+    if (!config) {
+        throw new Error("No local pairing found. Run `otto-bridge pair --code <CODE>` first.");
+    }
+    const runtimeConfig = {
+        ...config,
+        executor: resolveExecutorOverrides(args, config.executor),
+    };
+    const runtime = new BridgeRuntime(runtimeConfig);
+    await runtime.start();
+}
+async function runStatusCommand() {
+    const config = await loadBridgeConfig();
+    if (!config) {
+        console.log("[otto-bridge] not paired");
+        console.log(`[otto-bridge] expected config path=${getBridgeConfigPath()}`);
+        return;
+    }
+    console.log(JSON.stringify({
+        paired: true,
+        config_path: getBridgeConfigPath(),
+        device_id: config.deviceId,
+        device_name: config.deviceName,
+        api_base_url: config.apiBaseUrl,
+        ws_url: config.wsUrl,
+        approval_mode: config.approvalMode,
+        capabilities: config.capabilities,
+        paired_at: config.pairedAt,
+        executor: config.executor,
+    }, null, 2));
+}
+async function runUnpairCommand() {
+    await clearBridgeConfig();
+    console.log("[otto-bridge] local pairing cleared");
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    switch (args.command) {
+        case "pair":
+            await runPairCommand(args);
+            return;
+        case "run":
+            await runRuntimeCommand(args);
+            return;
+        case "status":
+            await runStatusCommand();
+            return;
+        case "unpair":
+            await runUnpairCommand();
+            return;
+        case "help":
+        case "--help":
+        case "-h":
+            printUsage();
+            return;
+        default:
+            printUsage();
+            throw new Error(`Unknown command: ${args.command}`);
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[otto-bridge] ${message}`);
+    process.exitCode = 1;
+});

package/dist/pairing.js

@@ -0,0 +1,56 @@
+import { platform } from "node:os";
+import { buildBridgeConfig, buildDeviceFingerprint, buildDeviceMetadata, defaultDeviceName, resolveApiBaseUrl, saveBridgeConfig, } from "./config.js";
+import { postJson } from "./http.js";
+import { BRIDGE_VERSION, DEFAULT_PAIR_TIMEOUT_SECONDS, DEFAULT_POLL_INTERVAL_MS, } from "./types.js";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function pairDevice(options) {
+    const apiBaseUrl = resolveApiBaseUrl(options.apiBaseUrl);
+    const deviceName = String(options.deviceName || defaultDeviceName()).trim() || defaultDeviceName();
+    const timeoutMs = Math.max(15, Number(options.timeoutSeconds || DEFAULT_PAIR_TIMEOUT_SECONDS)) * 1000;
+    const pollIntervalMs = Math.max(1000, Number(options.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS));
+    const claimResponse = await postJson(apiBaseUrl, "/v1/devices/pairing/claim", {
+        code: options.pairingCode,
+        device_name: deviceName,
+        platform: platform(),
+        bridge_version: BRIDGE_VERSION,
+        device_fingerprint: buildDeviceFingerprint(),
+        metadata: buildDeviceMetadata(),
+    });
+    const claim = claimResponse.claim;
+    if (!claim?.claim_id || !claim.claim_token) {
+        throw new Error("Pairing claim response missing claim token");
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        const pollResponse = await postJson(apiBaseUrl, "/v1/devices/pairing/poll", {
+            claim_id: claim.claim_id,
+            claim_token: claim.claim_token,
+        });
+        const currentClaim = pollResponse.claim;
+        if (currentClaim.status === "approved") {
+            if (!currentClaim.device_id || !currentClaim.device_token) {
+                throw new Error("Approved claim missing device credentials");
+            }
+            const config = buildBridgeConfig({
+                apiBaseUrl,
+                deviceId: currentClaim.device_id,
+                deviceToken: currentClaim.device_token,
+                deviceName: currentClaim.device_name || deviceName,
+                approvalMode: currentClaim.approval_mode,
+                capabilities: currentClaim.capabilities,
+                metadata: currentClaim.metadata,
+                executor: options.executor,
+            });
+            await saveBridgeConfig(config);
+            return config;
+        }
+        if (currentClaim.status === "rejected") {
+            const reason = currentClaim.reason ? `: ${currentClaim.reason}` : "";
+            throw new Error(`Pairing rejected${reason}`);
+        }
+        await sleep(pollIntervalMs);
+    }
+    throw new Error("Timed out waiting for pairing approval");
+}

package/dist/runtime.js

@@ -0,0 +1,254 @@
+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";
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function parseSocketMessage(data) {
+    if (typeof data === "string") {
+        return JSON.parse(data);
+    }
+    if (data instanceof Blob) {
+        return JSON.parse(await data.text());
+    }
+    if (data instanceof ArrayBuffer) {
+        return JSON.parse(Buffer.from(data).toString("utf8"));
+    }
+    if (ArrayBuffer.isView(data)) {
+        return JSON.parse(Buffer.from(data.buffer).toString("utf8"));
+    }
+    return data;
+}
+export class BridgeRuntime {
+    config;
+    reconnectDelayMs = DEFAULT_RECONNECT_BASE_DELAY_MS;
+    executor;
+    pendingConfirmations = new Map();
+    constructor(config, executor) {
+        this.config = config;
+        this.executor = executor ?? this.createDefaultExecutor(config);
+    }
+    async start() {
+        console.log(`[otto-bridge] runtime start device=${this.config.deviceId}`);
+        while (true) {
+            try {
+                await this.connectOnce();
+                this.reconnectDelayMs = DEFAULT_RECONNECT_BASE_DELAY_MS;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`[otto-bridge] socket error: ${message}`);
+            }
+            console.log(`[otto-bridge] reconnecting in ${this.reconnectDelayMs}ms`);
+            await delay(this.reconnectDelayMs);
+            this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, DEFAULT_RECONNECT_MAX_DELAY_MS);
+        }
+    }
+    async connectOnce() {
+        const socket = new WebSocket(this.config.wsUrl, ["device", this.config.deviceToken]);
+        let heartbeatTimer = null;
+        const stopHeartbeat = () => {
+            if (heartbeatTimer) {
+                clearInterval(heartbeatTimer);
+                heartbeatTimer = null;
+            }
+        };
+        const rejectPendingConfirmations = (error) => {
+            for (const [jobId, waiter] of this.pendingConfirmations.entries()) {
+                waiter.reject(error);
+                this.pendingConfirmations.delete(jobId);
+            }
+        };
+        return await new Promise((resolve, reject) => {
+            socket.addEventListener("open", () => {
+                console.log(`[otto-bridge] connected ws=${this.config.wsUrl}`);
+                socket.send(JSON.stringify({
+                    type: "device.hello",
+                    device_id: this.config.deviceId,
+                    device_name: this.config.deviceName,
+                    bridge_version: this.config.bridgeVersion,
+                    capabilities: this.config.capabilities,
+                    metadata: this.config.metadata,
+                }));
+                heartbeatTimer = setInterval(() => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        socket.send(JSON.stringify({
+                            type: "device.heartbeat",
+                            device_id: this.config.deviceId,
+                            sent_at: Date.now(),
+                        }));
+                    }
+                }, DEFAULT_HEARTBEAT_INTERVAL_MS);
+            });
+            socket.addEventListener("message", async (event) => {
+                try {
+                    const message = await parseSocketMessage(event.data);
+                    await this.handleMessage(socket, message);
+                }
+                catch (error) {
+                    const detail = error instanceof Error ? error.message : String(error);
+                    console.error(`[otto-bridge] invalid message: ${detail}`);
+                }
+            });
+            socket.addEventListener("close", (event) => {
+                stopHeartbeat();
+                rejectPendingConfirmations(new Error("WebSocket closed while awaiting confirmation"));
+                console.log(`[otto-bridge] socket closed code=${event.code}`);
+                resolve();
+            });
+            socket.addEventListener("error", () => {
+                stopHeartbeat();
+                rejectPendingConfirmations(new Error("WebSocket failed while awaiting confirmation"));
+                try {
+                    socket.close();
+                }
+                catch {
+                    // no-op
+                }
+                reject(new Error("WebSocket connection failed"));
+            });
+        });
+    }
+    async handleMessage(socket, message) {
+        const type = String(message.type || "");
+        switch (type) {
+            case "device.hello":
+                console.log(`[otto-bridge] server hello device=${String(message.device_id || "")}`);
+                return;
+            case "device.hello_ack":
+            case "device.heartbeat_ack":
+                return;
+            case "device.job.start":
+                console.log(`[otto-bridge] job start payload=${JSON.stringify(message)}`);
+                this.executeJob(socket, {
+                    job_id: String(message.job_id || ""),
+                    device_id: String(message.device_id || ""),
+                    job_type: String(message.job_type || "task"),
+                    payload: (message.payload && typeof message.payload === "object")
+                        ? message.payload
+                        : {},
+                }).catch((error) => {
+                    const detail = error instanceof Error ? error.message : String(error);
+                    console.error(`[otto-bridge] executor error: ${detail}`);
+                });
+                return;
+            case "device.job.confirmation":
+                this.resolveConfirmation(message);
+                return;
+            default:
+                console.log(`[otto-bridge] event=${type || "unknown"} payload=${JSON.stringify(message)}`);
+        }
+    }
+    resolveConfirmation(message) {
+        const jobId = String(message.job_id || "");
+        const action = String(message.action || "").trim().toLowerCase();
+        const waiter = this.pendingConfirmations.get(jobId);
+        if (!jobId || !waiter) {
+            console.warn(`[otto-bridge] unexpected confirmation payload=${JSON.stringify(message)}`);
+            return;
+        }
+        if (action !== "approve" && action !== "reject") {
+            waiter.reject(new Error(`Unsupported confirmation action: ${action || "unknown"}`));
+            this.pendingConfirmations.delete(jobId);
+            return;
+        }
+        this.pendingConfirmations.delete(jobId);
+        waiter.resolve({
+            action,
+            note: typeof message.note === "string" ? message.note : undefined,
+        });
+    }
+    async waitForConfirmation(jobId) {
+        return await new Promise((resolve, reject) => {
+            this.pendingConfirmations.set(jobId, { resolve, reject });
+        });
+    }
+    async executeJob(socket, job) {
+        const sendJson = async (payload) => {
+            if (socket.readyState !== WebSocket.OPEN) {
+                throw new Error("Socket is not open");
+            }
+            socket.send(JSON.stringify(payload));
+        };
+        try {
+            await this.executor.run(job, {
+                accepted: async () => {
+                    await sendJson({
+                        type: "device.job.accepted",
+                        device_id: this.config.deviceId,
+                        job_id: job.job_id,
+                        accepted_at: Date.now(),
+                    });
+                },
+                progress: async (progressPercent, progressMessage) => {
+                    await sendJson({
+                        type: "device.job.progress",
+                        device_id: this.config.deviceId,
+                        job_id: job.job_id,
+                        progress_percent: progressPercent,
+                        progress_message: progressMessage,
+                    });
+                },
+                confirmRequired: async (progressMessage, confirmationContext) => {
+                    const confirmationPromise = this.waitForConfirmation(job.job_id);
+                    try {
+                        await sendJson({
+                            type: "device.job.confirm_required",
+                            device_id: this.config.deviceId,
+                            job_id: job.job_id,
+                            progress_message: progressMessage,
+                            confirmation_context: confirmationContext || {},
+                        });
+                    }
+                    catch (error) {
+                        this.pendingConfirmations.delete(job.job_id);
+                        throw error;
+                    }
+                    return await confirmationPromise;
+                },
+                completed: async (result) => {
+                    await sendJson({
+                        type: "device.job.completed",
+                        device_id: this.config.deviceId,
+                        job_id: job.job_id,
+                        result: result || {},
+                    });
+                },
+                failed: async (errorMessage, result) => {
+                    await sendJson({
+                        type: "device.job.failed",
+                        device_id: this.config.deviceId,
+                        job_id: job.job_id,
+                        error_message: errorMessage,
+                        result: result || {},
+                    });
+                },
+            });
+        }
+        catch (error) {
+            this.pendingConfirmations.delete(job.job_id);
+            const detail = error instanceof Error ? error.message : String(error);
+            try {
+                await sendJson({
+                    type: "device.job.failed",
+                    device_id: this.config.deviceId,
+                    job_id: job.job_id,
+                    error_message: detail || "Executor failed",
+                    result: {
+                        executor: this.config.executor.type,
+                    },
+                });
+            }
+            catch {
+                // If the socket is already down, the reconnect path will recover but this job stays failed locally only.
+            }
+            throw error;
+        }
+    }
+    createDefaultExecutor(config) {
+        if (config.executor.type === "clawd-cursor") {
+            return new ClawdCursorJobExecutor(config.executor);
+        }
+        return new MockJobExecutor();
+    }
+}

package/dist/types.js

@@ -0,0 +1,11 @@
+export const BRIDGE_CONFIG_VERSION = 1;
+export const BRIDGE_VERSION = "0.1.0";
+export const DEFAULT_API_BASE_URL = "http://localhost:8000";
+export const DEFAULT_POLL_INTERVAL_MS = 3000;
+export const DEFAULT_PAIR_TIMEOUT_SECONDS = 600;
+export const DEFAULT_HEARTBEAT_INTERVAL_MS = 30000;
+export const DEFAULT_RECONNECT_BASE_DELAY_MS = 1500;
+export const DEFAULT_RECONNECT_MAX_DELAY_MS = 15000;
+export const DEFAULT_EXECUTOR_TYPE = "mock";
+export const DEFAULT_CLAWD_CURSOR_BASE_URL = "http://127.0.0.1:3847";
+export const DEFAULT_CLAWD_CURSOR_POLL_INTERVAL_MS = 1500;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@leg3ndy/otto-bridge",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",
+  "keywords": [
+    "otto",
+    "bridge",
+    "desktop-automation",
+    "companion",
+    "agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LGCYYL/ottoai.git",
+    "directory": "otto-bridge"
+  },
+  "bugs": {
+    "url": "https://github.com/LGCYYL/ottoai/issues"
+  },
+  "homepage": "https://github.com/LGCYYL/ottoai/tree/main/otto-bridge",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "bin": {
+    "otto-bridge": "dist/main.js"
+  },
+  "scripts": {
+    "build": "node ./scripts/run-tsc.mjs -p tsconfig.json",
+    "typecheck": "node ./scripts/run-tsc.mjs -p tsconfig.json --noEmit",
+    "pack:dry-run": "npm pack --dry-run",
+    "release:check": "npm run typecheck && npm run build && npm run pack:dry-run",
+    "prepublishOnly": "npm run release:check",
+    "pair": "node dist/main.js pair",
+    "run": "node dist/main.js run",
+    "status": "node dist/main.js status",
+    "unpair": "node dist/main.js unpair"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "typescript": "^5.9.3"
+  }
+}