@leg3ndy/otto-bridge 0.1.3 → 0.3.0

package/README.md

@@ -5,7 +5,7 @@ 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`
+- executar jobs locais com executor proprio do Otto no macOS, `mock` ou `clawd-cursor`
 
 ## Guia de uso
 
@@ -31,7 +31,7 @@ Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./leg3ndy-otto-bridge-0.1.3.tgz
+npm install -g ./leg3ndy-otto-bridge-0.3.0.tgz
 ```
 
 ## Publicacao
@@ -66,7 +66,7 @@ otto-bridge --help
 ### Parear o dispositivo
 
 ```bash
-otto-bridge pair --api http://localhost:8000 --code ABC123 --executor clawd-cursor
+otto-bridge pair --api http://localhost:8000 --code ABC123
 ```
 
 Opcoes suportadas:
@@ -74,18 +74,32 @@ 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`
+- `--executor`: `native-macos`, `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`
 
+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
 
 ```bash
-otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
+otto-bridge run
 ```
 
 Se o executor estiver salvo no `config.json`, o `run` usa essa configuracao por padrao.
 
+Para forcar o executor nativo no macOS sem reparar:
+
+```bash
+otto-bridge run --executor native-macos
+```
+
+O adapter `clawd-cursor` continua disponivel como override opcional:
+
+```bash
+otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
+```
+
 ### Ver estado local
 
 ```bash
@@ -136,7 +150,7 @@ otto-bridge unpair
 
 ## Payload esperado para jobs desktop
 
-O adapter do `clawd-cursor` procura a tarefa em uma destas chaves, nessa ordem:
+Os executores locais do Otto Bridge procuram a tarefa em uma destas chaves, nessa ordem:
 
 - `task`
 - `prompt`
@@ -144,6 +158,20 @@ O adapter do `clawd-cursor` procura a tarefa em uma destas chaves, nessa ordem:
 - `instructions`
 - `message`
 
+O executor nativo do macOS tambem aceita payload estruturado em `actions[]`, por exemplo:
+
+```json
+{
+  "job_type": "desktop_actions",
+  "payload": {
+    "actions": [
+      { "type": "open_app", "app": "Safari" },
+      { "type": "open_url", "url": "https://www.youtube.com", "app": "Safari" }
+    ]
+  }
+}
+```
+
 Exemplo:
 
 ```json

package/dist/config.js

@@ -2,7 +2,7 @@ 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";
+import { BRIDGE_CONFIG_VERSION, BRIDGE_VERSION, DEFAULT_CLAWD_CURSOR_BASE_URL, DEFAULT_CLAWD_CURSOR_POLL_INTERVAL_MS, DEFAULT_API_BASE_URL, } from "./types.js";
 function sanitizeApiBaseUrl(value) {
     const raw = String(value || DEFAULT_API_BASE_URL).trim();
     if (!raw) {
@@ -10,8 +10,14 @@ function sanitizeApiBaseUrl(value) {
     }
     return raw.replace(/\/+$/, "");
 }
+function resolveDefaultExecutorType() {
+    return platform() === "darwin" ? "native-macos" : "mock";
+}
 function sanitizeExecutorType(value) {
-    return value === "clawd-cursor" ? "clawd-cursor" : DEFAULT_EXECUTOR_TYPE;
+    if (value === "clawd-cursor" || value === "native-macos" || value === "mock") {
+        return value;
+    }
+    return resolveDefaultExecutorType();
 }
 function sanitizeClawdCursorBaseUrl(value) {
     const raw = String(value || DEFAULT_CLAWD_CURSOR_BASE_URL).trim();
@@ -27,6 +33,16 @@ function sanitizePollIntervalMs(value, fallback = DEFAULT_CLAWD_CURSOR_POLL_INTE
     }
     return Math.max(250, Math.floor(parsed));
 }
+function migrateLegacyExecutor(current) {
+    if (platform() === "darwin"
+        && current?.type === "clawd-cursor"
+        && sanitizeClawdCursorBaseUrl(current.baseUrl) === DEFAULT_CLAWD_CURSOR_BASE_URL) {
+        // Old macOS pairings defaulted to clawd-cursor while the bridge was still bootstrapping.
+        // Newer builds should run Otto's native executor by default without forcing users to re-pair.
+        return { type: "native-macos" };
+    }
+    return current || null;
+}
 export function getBridgeHomeDir() {
     const custom = String(process.env.OTTO_BRIDGE_HOME || "").trim();
     return custom || path.join(homedir(), ".otto-bridge");
@@ -51,7 +67,7 @@ export async function loadBridgeConfig() {
             ...parsed,
             apiBaseUrl: sanitizeApiBaseUrl(parsed.apiBaseUrl),
             wsUrl: buildWebSocketUrl(parsed.apiBaseUrl),
-            executor: resolveExecutorConfig(undefined, parsed.executor),
+            executor: resolveExecutorConfig(undefined, migrateLegacyExecutor(parsed.executor)),
         };
     }
     catch {
@@ -83,6 +99,9 @@ export function resolveExecutorConfig(overrides, current) {
                 ?? process.env.OTTO_CLAWD_POLL_INTERVAL_MS),
         };
     }
+    if (type === "native-macos") {
+        return { type: "native-macos" };
+    }
     return { type: "mock" };
 }
 export function buildWebSocketUrl(apiBaseUrl) {

package/dist/executors/native_macos.js

@@ -0,0 +1,400 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { JobCancelledError } from "./shared.js";
+const KNOWN_APPS = [
+    { canonical: "Safari", patterns: [/\bsafari\b/i] },
+    { canonical: "Google Chrome", patterns: [/\bgoogle chrome\b/i, /\bchrome\b/i] },
+    { canonical: "Firefox", patterns: [/\bfirefox\b/i] },
+    { canonical: "Spotify", patterns: [/\bspotify\b/i, /\bspofity\b/i] },
+    { canonical: "Finder", patterns: [/\bfinder\b/i] },
+    { canonical: "Notes", patterns: [/\bnotes\b/i, /\bnotas\b/i] },
+    { canonical: "TextEdit", patterns: [/\btextedit\b/i, /\bbloco de notas\b/i, /\beditor de texto\b/i] },
+    { canonical: "Mail", patterns: [/\bmail\b/i] },
+    { canonical: "Messages", patterns: [/\bmessages\b/i, /\bmensagens\b/i] },
+    { canonical: "Calendar", patterns: [/\bcalendar\b/i, /\bcalend[áa]rio\b/i] },
+    { canonical: "Terminal", patterns: [/\bterminal\b/i] },
+    { canonical: "System Settings", patterns: [/\bsystem settings\b/i, /\bajustes do sistema\b/i, /\bconfigura[cç][õo]es do sistema\b/i] },
+];
+const KNOWN_SITES = [
+    { url: "https://www.youtube.com", patterns: [/\byoutube\b/i, /\byou tube\b/i] },
+    { url: "https://www.instagram.com", patterns: [/\binstagram\b/i, /\binstagram\.com\b/i] },
+    { url: "https://mail.google.com", patterns: [/\bgmail\b/i] },
+    { url: "https://www.google.com", patterns: [/\bgoogle\b/i] },
+    { url: "https://github.com", patterns: [/\bgithub\b/i] },
+    { url: "https://chat.openai.com", patterns: [/\bchatgpt\b/i] },
+    { url: "https://web.whatsapp.com", patterns: [/\bwhatsapp\b/i] },
+    { url: "https://x.com", patterns: [/\bx\.com\b/i, /\btwitter\b/i, /\bxis\b/i] },
+];
+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 normalizeText(value) {
+    return value
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
+        .toLowerCase();
+}
+function escapeAppleScript(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+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;
+        }
+    }
+    return `Execute Otto job ${job.job_type}`;
+}
+function normalizeUrl(raw) {
+    const trimmed = raw.trim();
+    if (/^https?:\/\//i.test(trimmed)) {
+        return trimmed;
+    }
+    return `https://${trimmed.replace(/^\/+/, "")}`;
+}
+function splitTextForTyping(value) {
+    const parts = [];
+    for (const line of value.split("\n")) {
+        if (line.length <= 220) {
+            parts.push(line);
+            continue;
+        }
+        for (let index = 0; index < line.length; index += 220) {
+            parts.push(line.slice(index, index + 220));
+        }
+    }
+    return parts;
+}
+function extractConfirmationOptions(job, actions) {
+    const payload = asRecord(job.payload);
+    const requested = payload.requires_confirmation === true;
+    const longTyping = actions.some((action) => action.type === "type_text" && action.text.trim().length >= 180);
+    const confirmationMessage = asString(payload.confirmation_message)
+        || `O Otto quer executar ${actions.length} ação${actions.length === 1 ? "" : "ões"} no seu Mac.`;
+    return {
+        required: requested || longTyping,
+        message: confirmationMessage,
+    };
+}
+function parseShortcut(shortcut) {
+    const parts = shortcut
+        .split("+")
+        .map((part) => part.trim().toLowerCase())
+        .filter(Boolean);
+    const key = parts.pop() || "";
+    const modifiers = parts.map((part) => {
+        if (part === "cmd" || part === "command")
+            return "command down";
+        if (part === "shift")
+            return "shift down";
+        if (part === "alt" || part === "option")
+            return "option down";
+        if (part === "ctrl" || part === "control")
+            return "control down";
+        return "";
+    }).filter(Boolean);
+    return { key, modifiers };
+}
+function detectKnownApp(task) {
+    for (const app of KNOWN_APPS) {
+        if (app.patterns.some((pattern) => pattern.test(task))) {
+            return app.canonical;
+        }
+    }
+    return null;
+}
+function detectUrl(task) {
+    const explicitMatch = task.match(/https?:\/\/[^\s]+/i);
+    if (explicitMatch?.[0]) {
+        return normalizeUrl(explicitMatch[0]);
+    }
+    const normalized = normalizeText(task);
+    for (const site of KNOWN_SITES) {
+        if (site.patterns.some((pattern) => pattern.test(normalized))) {
+            return site.url;
+        }
+    }
+    return null;
+}
+function parseStructuredActions(job) {
+    const payload = asRecord(job.payload);
+    const rawActions = Array.isArray(payload.actions) ? payload.actions : [];
+    const actions = [];
+    for (const rawAction of rawActions) {
+        const action = asRecord(rawAction);
+        const type = asString(action.type);
+        if (!type) {
+            continue;
+        }
+        if (type === "open_app" || type === "focus_app") {
+            const app = asString(action.app) || asString(action.application) || asString(action.name);
+            if (app) {
+                actions.push({ type, app });
+            }
+            continue;
+        }
+        if (type === "open_url") {
+            const url = asString(action.url) || asString(action.href);
+            const app = asString(action.app) || asString(action.application);
+            if (url) {
+                actions.push({ type: "open_url", url: normalizeUrl(url), app: app || undefined });
+            }
+            continue;
+        }
+        if (type === "type_text" || type === "write_text" || type === "keystroke") {
+            const text = asString(action.text) || asString(action.content);
+            if (text) {
+                actions.push({ type: "type_text", text });
+            }
+            continue;
+        }
+        if (type === "press_shortcut" || type === "shortcut") {
+            const shortcut = asString(action.shortcut) || asString(action.keys);
+            if (shortcut) {
+                actions.push({ type: "press_shortcut", shortcut });
+            }
+        }
+    }
+    return actions;
+}
+function deriveActionsFromText(job) {
+    const task = extractTaskText(job);
+    const detectedApp = detectKnownApp(task);
+    const detectedUrl = detectUrl(task);
+    if (detectedUrl) {
+        return [{
+                type: "open_url",
+                url: detectedUrl,
+                app: detectedApp || undefined,
+            }];
+    }
+    if (detectedApp) {
+        return [{
+                type: "open_app",
+                app: detectedApp,
+            }];
+    }
+    return [];
+}
+function extractActions(job) {
+    const structured = parseStructuredActions(job);
+    if (structured.length > 0) {
+        return structured;
+    }
+    return deriveActionsFromText(job);
+}
+export class NativeMacOSJobExecutor {
+    cancelledJobs = new Set();
+    activeChild = null;
+    async run(job, reporter) {
+        if (process.platform !== "darwin") {
+            throw new Error("The native-macos executor only runs on macOS");
+        }
+        const actions = extractActions(job);
+        if (actions.length === 0) {
+            throw new Error("Otto Bridge native-macos could not derive a supported local action from this request");
+        }
+        await reporter.accepted();
+        const confirmation = extractConfirmationOptions(job, actions);
+        if (confirmation.required) {
+            const decision = await reporter.confirmRequired(confirmation.message, {
+                actions,
+                executor: "native-macos",
+            });
+            if (decision.action !== "approve") {
+                throw new JobCancelledError(job.job_id);
+            }
+        }
+        try {
+            for (let index = 0; index < actions.length; index += 1) {
+                this.assertNotCancelled(job.job_id);
+                const action = actions[index];
+                const progressPercent = Math.max(10, Math.round(((index + 1) / actions.length) * 100));
+                if (action.type === "open_app") {
+                    await reporter.progress(progressPercent, `Abrindo ${action.app} no macOS`);
+                    await this.openApp(action.app);
+                    continue;
+                }
+                if (action.type === "focus_app") {
+                    await reporter.progress(progressPercent, `Trazendo ${action.app} para frente`);
+                    await this.focusApp(action.app);
+                    continue;
+                }
+                if (action.type === "press_shortcut") {
+                    await reporter.progress(progressPercent, `Enviando atalho ${action.shortcut}`);
+                    await this.pressShortcut(action.shortcut);
+                    continue;
+                }
+                if (action.type === "type_text") {
+                    await reporter.progress(progressPercent, "Digitando texto no app ativo");
+                    await this.typeText(action.text);
+                    continue;
+                }
+                await reporter.progress(progressPercent, `Abrindo ${action.url}${action.app ? ` em ${action.app}` : ""}`);
+                await this.openUrl(action.url, action.app);
+            }
+            const summary = actions.length === 1
+                ? this.describeAction(actions[0])
+                : `${actions.length} ações executadas no macOS`;
+            await reporter.completed({
+                executor: "native-macos",
+                summary,
+                actions,
+            });
+        }
+        finally {
+            this.cancelledJobs.delete(job.job_id);
+        }
+    }
+    async cancel(jobId) {
+        this.cancelledJobs.add(jobId);
+        if (this.activeChild) {
+            this.activeChild.kill("SIGTERM");
+            this.activeChild = null;
+        }
+    }
+    assertNotCancelled(jobId) {
+        if (this.cancelledJobs.has(jobId)) {
+            throw new JobCancelledError(jobId);
+        }
+    }
+    async openApp(app) {
+        await this.runCommand("open", ["-a", app]);
+        await this.focusApp(app);
+    }
+    async openUrl(url, app) {
+        if (app) {
+            await this.runCommand("open", ["-a", app, url]);
+            await this.focusApp(app);
+            return;
+        }
+        await this.runCommand("open", [url]);
+    }
+    async focusApp(app) {
+        await this.runCommand("osascript", ["-e", `tell application "${escapeAppleScript(app)}" to activate`]);
+    }
+    async pressShortcut(shortcut) {
+        const { key, modifiers } = parseShortcut(shortcut);
+        if (!key) {
+            throw new Error(`Invalid shortcut: ${shortcut}`);
+        }
+        const namedKeyCodes = {
+            return: 36,
+            enter: 36,
+            tab: 48,
+            space: 49,
+            escape: 53,
+            esc: 53,
+            left: 123,
+            right: 124,
+            down: 125,
+            up: 126,
+        };
+        const usingClause = modifiers.length > 0 ? ` using {${modifiers.join(", ")}}` : "";
+        if (namedKeyCodes[key] !== undefined) {
+            await this.runCommand("osascript", [
+                "-e",
+                `tell application "System Events" to key code ${namedKeyCodes[key]}${usingClause}`,
+            ]);
+            return;
+        }
+        await this.runCommand("osascript", [
+            "-e",
+            `tell application "System Events" to keystroke "${escapeAppleScript(key)}"${usingClause}`,
+        ]);
+    }
+    async typeText(text) {
+        const chunks = splitTextForTyping(text);
+        for (let index = 0; index < chunks.length; index += 1) {
+            const chunk = chunks[index];
+            if (chunk) {
+                await this.runCommand("osascript", [
+                    "-e",
+                    `tell application "System Events" to keystroke "${escapeAppleScript(chunk)}"`,
+                ]);
+            }
+            if (index < chunks.length - 1) {
+                await this.runCommand("osascript", [
+                    "-e",
+                    'tell application "System Events" to key code 36',
+                ]);
+            }
+        }
+    }
+    describeAction(action) {
+        if (action.type === "open_app") {
+            return `${action.app} foi aberto no macOS`;
+        }
+        if (action.type === "focus_app") {
+            return `${action.app} ficou em foco no macOS`;
+        }
+        if (action.type === "press_shortcut") {
+            return `Atalho ${action.shortcut} executado no macOS`;
+        }
+        if (action.type === "type_text") {
+            return "Texto digitado no aplicativo ativo";
+        }
+        return `${action.url} foi aberto${action.app ? ` em ${action.app}` : ""}`;
+    }
+    async runCommand(command, args) {
+        const child = spawn(command, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        this.activeChild = child;
+        try {
+            const { stdout, stderr } = await new Promise((resolve, reject) => {
+                let stdout = "";
+                let stderr = "";
+                child.stdout.on("data", (chunk) => {
+                    stdout += String(chunk);
+                });
+                child.stderr.on("data", (chunk) => {
+                    stderr += String(chunk);
+                });
+                child.on("error", (error) => {
+                    reject(error);
+                });
+                child.on("close", (code) => {
+                    if (code === 0) {
+                        resolve({ stdout, stderr });
+                        return;
+                    }
+                    reject(new Error(`${command} ${args.join(" ")} failed: ${stderr.trim() || stdout.trim() || `exit code ${code ?? "unknown"}`}`));
+                });
+            });
+            const stderrText = stderr.trim();
+            if (stderrText) {
+                console.warn(`[otto-bridge] ${command} stderr=${stderrText}`);
+            }
+            const stdoutText = stdout.trim();
+            if (stdoutText) {
+                console.log(`[otto-bridge] ${command} stdout=${stdoutText}`);
+            }
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(detail);
+        }
+        finally {
+            if (this.activeChild === child) {
+                this.activeChild = null;
+            }
+        }
+    }
+}

package/dist/main.js

@@ -53,15 +53,15 @@ function resolveExecutorOverrides(args, 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 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 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 pair --api https://api.leg3ndy.com.br --code ABC123
   otto-bridge run
   otto-bridge version
   otto-bridge update

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 { NativeMacOSJobExecutor } from "./executors/native_macos.js";
 import { JobCancelledError } from "./executors/shared.js";
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -278,6 +279,9 @@ export class BridgeRuntime {
         if (config.executor.type === "clawd-cursor") {
             return new ClawdCursorJobExecutor(config.executor);
         }
+        if (config.executor.type === "native-macos") {
+            return new NativeMacOSJobExecutor();
+        }
         return new MockJobExecutor();
     }
 }

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "0.1.3";
+export const BRIDGE_VERSION = "0.3.0";
 export const BRIDGE_PACKAGE_NAME = "@leg3ndy/otto-bridge";
 export const DEFAULT_API_BASE_URL = "http://localhost:8000";
 export const DEFAULT_POLL_INTERVAL_MS = 3000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leg3ndy/otto-bridge",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",