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

package/dist/executors/native_macos.js

@@ -1,4 +1,7 @@
 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 = [
@@ -17,6 +20,7 @@ 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] },
@@ -68,18 +72,77 @@ function normalizeUrl(raw) {
     }
     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));
-        }
+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;
     }
-    return parts;
+    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);
@@ -169,6 +232,33 @@ function parseStructuredActions(job) {
             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;
@@ -222,6 +312,7 @@ export class NativeMacOSJobExecutor {
             }
         }
         try {
+            const completionNotes = [];
             for (let index = 0; index < actions.length; index += 1) {
                 this.assertNotCancelled(job.job_id);
                 const action = actions[index];
@@ -246,12 +337,38 @@ export class NativeMacOSJobExecutor {
                     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,
@@ -320,22 +437,70 @@ export class NativeMacOSJobExecutor {
         ]);
     }
     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)}"`,
-                ]);
+        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);
             }
-            if (index < chunks.length - 1) {
-                await this.runCommand("osascript", [
-                    "-e",
-                    'tell application "System Events" to key code 36',
-                ]);
+        }
+    }
+    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") {
@@ -350,17 +515,40 @@ export class NativeMacOSJobExecutor {
         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);
                 });
@@ -386,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.3.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.3.0",
+  "version": "0.4.0",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",