@leg3ndy/otto-bridge 0.2.0 → 0.4.0

package/README.md

@@ -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.2.0.tgz
+npm install -g ./leg3ndy-otto-bridge-0.4.0.tgz
 ```
 
 ## Publicacao

package/dist/executors/native_macos.js

@@ -1,12 +1,17 @@
 import { spawn } from "node:child_process";
+import { mkdir, readFile, readdir, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 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] },
@@ -15,6 +20,8 @@ const KNOWN_APPS = [
 ];
 const KNOWN_SITES = [
     { url: "https://www.youtube.com", patterns: [/\byoutube\b/i, /\byou tube\b/i] },
+    { url: "https://music.youtube.com", patterns: [/\byoutube music\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] },
@@ -65,6 +72,108 @@ function normalizeUrl(raw) {
     }
     return `https://${trimmed.replace(/^\/+/, "")}`;
 }
+function expandUserPath(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return os.homedir();
+    }
+    if (trimmed === "~") {
+        return os.homedir();
+    }
+    if (trimmed.startsWith("~/")) {
+        return path.join(os.homedir(), trimmed.slice(2));
+    }
+    if (path.isAbsolute(trimmed)) {
+        return trimmed;
+    }
+    return path.resolve(process.cwd(), trimmed);
+}
+function clipText(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, maxLength)}...`;
+}
+function isSafeShellCommand(command) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return false;
+    }
+    const forbiddenPatterns = [
+        /(^|[;&|])\s*sudo\b/i,
+        /\brm\b/i,
+        /\bmv\b/i,
+        /\bcp\b/i,
+        /\bchmod\b/i,
+        /\bchown\b/i,
+        /\bshutdown\b/i,
+        /\breboot\b/i,
+        /\bmkfs\b/i,
+        /\bdd\b/i,
+        /\bkill(?:all)?\b/i,
+        />/,
+        />>/,
+    ];
+    if (forbiddenPatterns.some((pattern) => pattern.test(trimmed))) {
+        return false;
+    }
+    const normalized = trimmed.replace(/\s+/g, " ");
+    const allowedPrefixes = [
+        "pwd",
+        "ls",
+        "cat ",
+        "cat",
+        "sed ",
+        "rg ",
+        "find ",
+        "git status",
+        "git log",
+        "git diff",
+        "head ",
+        "tail ",
+        "wc ",
+        "stat ",
+        "file ",
+        "mdls ",
+        "whoami",
+        "date",
+        "uname",
+        "python3 --version",
+        "node -v",
+        "npm -v",
+    ];
+    return allowedPrefixes.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix} `));
+}
+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))) {
@@ -99,7 +208,7 @@ function parseStructuredActions(job) {
         if (type === "open_app" || type === "focus_app") {
             const app = asString(action.app) || asString(action.application) || asString(action.name);
             if (app) {
-                actions.push({ type: "open_app", app });
+                actions.push({ type, app });
             }
             continue;
         }
@@ -109,6 +218,47 @@ function parseStructuredActions(job) {
             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 });
+            }
+            continue;
+        }
+        if (type === "take_screenshot" || type === "screenshot" || type === "screen_capture") {
+            const savePath = asString(action.path) || asString(action.save_path);
+            actions.push({ type: "take_screenshot", path: savePath || undefined });
+            continue;
+        }
+        if (type === "read_file" || type === "read_local_file") {
+            const filePath = asString(action.path);
+            if (filePath) {
+                const maxChars = typeof action.max_chars === "number" ? Math.max(200, Math.min(12000, action.max_chars)) : undefined;
+                actions.push({ type: "read_file", path: filePath, max_chars: maxChars });
+            }
+            continue;
+        }
+        if (type === "list_files" || type === "ls") {
+            const filePath = asString(action.path) || "~";
+            const limit = typeof action.limit === "number" ? Math.max(1, Math.min(200, action.limit)) : undefined;
+            actions.push({ type: "list_files", path: filePath, limit });
+            continue;
+        }
+        if (type === "run_shell" || type === "shell" || type === "terminal") {
+            const command = asString(action.command) || asString(action.cmd);
+            const cwd = asString(action.cwd);
+            if (command) {
+                actions.push({ type: "run_shell", command, cwd: cwd || undefined });
+            }
         }
     }
     return actions;
@@ -151,7 +301,18 @@ export class NativeMacOSJobExecutor {
             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 {
+            const completionNotes = [];
             for (let index = 0; index < actions.length; index += 1) {
                 this.assertNotCancelled(job.job_id);
                 const action = actions[index];
@@ -161,12 +322,53 @@ export class NativeMacOSJobExecutor {
                     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;
+                }
+                if (action.type === "take_screenshot") {
+                    await reporter.progress(progressPercent, "Capturando screenshot do Mac");
+                    const screenshotPath = await this.takeScreenshot(action.path);
+                    completionNotes.push(`Screenshot salvo em ${screenshotPath}`);
+                    continue;
+                }
+                if (action.type === "read_file") {
+                    await reporter.progress(progressPercent, `Lendo ${action.path}`);
+                    const fileContent = await this.readLocalFile(action.path, action.max_chars);
+                    completionNotes.push(`Conteudo de ${action.path}:\n${fileContent}`);
+                    continue;
+                }
+                if (action.type === "list_files") {
+                    await reporter.progress(progressPercent, `Listando arquivos em ${action.path}`);
+                    const listing = await this.listLocalFiles(action.path, action.limit);
+                    completionNotes.push(`Arquivos em ${action.path}:\n${listing}`);
+                    continue;
+                }
+                if (action.type === "run_shell") {
+                    await reporter.progress(progressPercent, `Rodando comando local: ${action.command}`);
+                    const shellOutput = await this.runShellCommand(action.command, action.cwd);
+                    completionNotes.push(`Saida de \`${action.command}\`:\n${shellOutput}`);
+                    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`;
+            const summary = completionNotes.length > 0
+                ? completionNotes.join("\n\n")
+                : (actions.length === 1
+                    ? this.describeAction(actions[0])
+                    : `${actions.length} ações executadas no macOS`);
             await reporter.completed({
                 executor: "native-macos",
                 summary,
@@ -191,31 +393,162 @@ export class NativeMacOSJobExecutor {
     }
     async openApp(app) {
         await this.runCommand("open", ["-a", app]);
-        await this.runCommand("osascript", ["-e", `tell application "${escapeAppleScript(app)}" to activate`]);
+        await this.focusApp(app);
     }
     async openUrl(url, app) {
         if (app) {
             await this.runCommand("open", ["-a", app, url]);
-            await this.runCommand("osascript", ["-e", `tell application "${escapeAppleScript(app)}" to activate`]);
+            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 previousClipboard = await this.readClipboardText();
+        try {
+            await this.writeClipboardText(text);
+            await this.pressShortcut("cmd+v");
+        }
+        finally {
+            if (previousClipboard !== null) {
+                await this.writeClipboardText(previousClipboard).catch(() => undefined);
+            }
+        }
+    }
+    async takeScreenshot(targetPath) {
+        const artifactsDir = path.join(os.homedir(), ".otto-bridge", "artifacts");
+        await mkdir(artifactsDir, { recursive: true });
+        const screenshotPath = targetPath
+            ? expandUserPath(targetPath)
+            : path.join(artifactsDir, `screenshot-${Date.now()}.png`);
+        await this.runCommand("screencapture", ["-x", screenshotPath]);
+        return screenshotPath;
+    }
+    async readLocalFile(filePath, maxChars = 4000) {
+        const resolved = expandUserPath(filePath);
+        const content = await readFile(resolved, "utf8");
+        return clipText(content.trim() || "(arquivo vazio)", maxChars);
+    }
+    async listLocalFiles(directoryPath, limit = 40) {
+        const resolved = expandUserPath(directoryPath);
+        const entries = await readdir(resolved, { withFileTypes: true });
+        const items = await Promise.all(entries.slice(0, limit).map(async (entry) => {
+            const entryPath = path.join(resolved, entry.name);
+            let suffix = "";
+            try {
+                const entryStat = await stat(entryPath);
+                suffix = entry.isDirectory() ? "/" : ` (${entryStat.size} bytes)`;
+            }
+            catch {
+                suffix = entry.isDirectory() ? "/" : "";
+            }
+            return `${entry.name}${suffix}`;
+        }));
+        return items.length > 0 ? items.join("\n") : "(pasta vazia)";
+    }
+    async runShellCommand(command, cwd) {
+        if (!isSafeShellCommand(command)) {
+            throw new Error("Otto Bridge permite apenas shell de consulta no momento. Use comandos de leitura como pwd, ls, cat, rg, find ou git status.");
+        }
+        const resolvedCwd = cwd ? expandUserPath(cwd) : process.cwd();
+        const { stdout, stderr } = await this.runCommandCapture("/bin/zsh", ["-lc", command], {
+            cwd: resolvedCwd,
+        });
+        const combined = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
+        return clipText(combined || "(sem saida)", 4000);
+    }
+    async readClipboardText() {
+        try {
+            const { stdout } = await this.runCommandCapture("pbpaste", []);
+            return stdout;
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeClipboardText(text) {
+        await this.runCommandCapture("pbcopy", [], { stdin: text });
+    }
     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";
+        }
+        if (action.type === "take_screenshot") {
+            return "Screenshot capturado no macOS";
+        }
+        if (action.type === "read_file") {
+            return `${action.path} foi lido no macOS`;
+        }
+        if (action.type === "list_files") {
+            return `Arquivos listados em ${action.path}`;
+        }
+        if (action.type === "run_shell") {
+            return `Comando ${action.command} executado no macOS`;
+        }
         return `${action.url} foi aberto${action.app ? ` em ${action.app}` : ""}`;
     }
     async runCommand(command, args) {
+        await this.runCommandCapture(command, args);
+    }
+    async runCommandCapture(command, args, options) {
         const child = spawn(command, args, {
-            stdio: ["ignore", "pipe", "pipe"],
+            cwd: options?.cwd,
+            stdio: ["pipe", "pipe", "pipe"],
         });
         this.activeChild = child;
         try {
             const { stdout, stderr } = await new Promise((resolve, reject) => {
                 let stdout = "";
                 let stderr = "";
+                if (options?.stdin !== undefined) {
+                    child.stdin.write(options.stdin);
+                    child.stdin.end();
+                }
+                else {
+                    child.stdin.end();
+                }
                 child.stdout.on("data", (chunk) => {
                     stdout += String(chunk);
                 });
@@ -241,9 +574,13 @@ export class NativeMacOSJobExecutor {
             if (stdoutText) {
                 console.log(`[otto-bridge] ${command} stdout=${stdoutText}`);
             }
+            return { stdout, stderr };
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
+            if (detail.includes("System Events") || detail.includes("(1002)")) {
+                throw new Error("macOS bloqueou o controle de teclado do Otto Bridge. Abra Ajustes do Sistema > Privacidade e Seguranca > Acessibilidade e autorize o terminal ou app que esta rodando o otto-bridge.");
+            }
             throw new Error(detail);
         }
         finally {

package/dist/types.js

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