@leg3ndy/otto-bridge 0.9.0 → 0.9.2

package/README.md

@@ -15,6 +15,8 @@ Para o estado atual da arquitetura, capacidades entregues, limitacoes e roadmap
 
 Para o corte de arquitetura do `0.9.0`, veja [`leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_0_RELEASE.md`](../leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_0_RELEASE.md).
 
+Para o patch atual `0.9.2`, com confirmacao bloqueante correta e exclusao segura via Lixeira, veja [`leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_2_PATCH.md`](../leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_2_PATCH.md).
+
 ## Distribuicao
 
 Fluxo recomendado agora:
@@ -35,14 +37,14 @@ Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./leg3ndy-otto-bridge-0.9.0.tgz
+npm install -g ./leg3ndy-otto-bridge-0.9.2.tgz
 ```
 
-No `0.9.0`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
+Na linha `0.9.2`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
 
-No macOS, o `0.9.0` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
+No macOS, a linha `0.9.2` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
 
-No nivel arquitetural, o `0.9.0` muda o papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat.
+No nivel arquitetural, o `0.9.0` marcou a mudanca de papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat. O `0.9.2` consolida esse caminho com confirmacao bloqueante correta, exclusao segura via Lixeira, planner LLM-first e leitura/listagem local sem truncamento silencioso.
 
 ## Publicacao
 
@@ -112,7 +114,7 @@ otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
 
 ### WhatsApp Web em background
 
-Fluxo recomendado no `0.9.0`:
+Fluxo recomendado na linha `0.9.2`:
 
 ```bash
 otto-bridge extensions --install whatsappweb
@@ -122,13 +124,13 @@ otto-bridge extensions --status whatsappweb
 
 O setup agora abre o login do WhatsApp Web no helper/background browser do proprio bridge. Depois do QR code, o Otto usa a sessao local em background, sem depender de aba visivel no Safari.
 
-Contrato do `0.9.0`:
+Contrato da linha `0.9.2`:
 
 - `otto-bridge extensions --setup whatsappweb`: autentica a sessao uma vez
 - `otto-bridge run`: mantem o browser persistente do WhatsApp vivo em background enquanto o runtime estiver ativo, sem depender de uma aba aberta no Safari
 - ao parar o `otto-bridge run`: o browser em background e desligado, mas a sessao local fica lembrada para o proximo boot
 
-## Handoff rapido do 0.9.0
+## Handoff rapido da linha 0.9.2
 
 Ja fechado no codigo:
 
@@ -138,6 +140,9 @@ Ja fechado no codigo:
 - prompt bridge-aware no chat normal para ajudar o Otto a responder com base no que realmente aconteceu no device
 - runtime local agora publica `local_tools` para o Otto/backend saberem exatamente o que o device consegue fazer
 - o caminho principal do bridge usa `summary`/`narration_context` no lugar de resposta automatica pronta
+- `read_file` agora entrega conteudo completo segmentado em `content_chunks` para o Otto
+- `list_files` sem `limit` agora lista o diretorio inteiro, sem fallback silencioso para 40 itens
+- o planner do bridge prioriza o modelo para escolher a tool certa pelo contexto; regex fica como fallback
 
 Ainda precisa reteste em campo:
 

package/dist/executors/native_macos.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { mkdir, readFile, readdir, stat } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
@@ -702,6 +702,46 @@ function clipTextPreview(value, maxLength) {
     }
     return `${value.slice(0, maxLength)}\n\n[conteudo truncado: mostrando ${maxLength} de ${value.length} caracteres. Peca um trecho mais especifico se quiser continuar.]`;
 }
+function sanitizeFileName(value, fallback = "otto-note.txt") {
+    const normalized = String(value || "")
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
+        .replace(/[\/\\?%*:|"<>]/g, "-")
+        .replace(/\s+/g, " ")
+        .trim();
+    const collapsed = normalized.replace(/\.+/g, ".").replace(/^\.+/, "").replace(/\.+$/, "");
+    const candidate = collapsed || fallback;
+    return path.extname(candidate) ? candidate : `${candidate}.txt`;
+}
+function chunkTextForTransport(value, chunkSize) {
+    const normalized = String(value || "");
+    if (!normalized) {
+        return [];
+    }
+    const safeChunkSize = Math.max(400, Math.min(Math.round(chunkSize || 4000), 32_000));
+    const chunks = [];
+    let cursor = 0;
+    let index = 0;
+    while (cursor < normalized.length) {
+        let nextCursor = Math.min(normalized.length, cursor + safeChunkSize);
+        if (nextCursor < normalized.length) {
+            const lastLineBreak = normalized.lastIndexOf("\n", nextCursor);
+            if (lastLineBreak > cursor + Math.floor(safeChunkSize * 0.35)) {
+                nextCursor = lastLineBreak + 1;
+            }
+        }
+        const text = normalized.slice(cursor, nextCursor);
+        chunks.push({
+            index,
+            start_char: cursor,
+            end_char: nextCursor,
+            text,
+        });
+        cursor = nextCursor;
+        index += 1;
+    }
+    return chunks;
+}
 const TEXTUTIL_READABLE_EXTENSIONS = new Set([
     ".doc",
     ".docx",
@@ -975,14 +1015,38 @@ function parseStructuredActions(job) {
         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;
+                const maxChars = typeof action.max_chars === "number" ? Math.max(400, Math.min(32_000, action.max_chars)) : undefined;
                 actions.push({ type: "read_file", path: filePath, max_chars: maxChars });
             }
             continue;
         }
+        if (type === "write_text_file" || type === "write_file" || type === "save_text_file" || type === "save_file") {
+            const targetPath = asString(action.path)
+                || asString(action.destination)
+                || asString(action.file_path)
+                || asString(action.target)
+                || asString(action.directory)
+                || asString(action.folder)
+                || (asString(action.filename) ? "~/Desktop" : "");
+            const text = asString(action.text) || asString(action.content) || asString(action.body) || asString(action.value);
+            const source = asString(action.source) || asString(action.input_source);
+            if (targetPath && (text || source)) {
+                actions.push({
+                    type: "write_text_file",
+                    path: targetPath,
+                    text: text || undefined,
+                    content: asString(action.content) || undefined,
+                    body: asString(action.body) || undefined,
+                    source: source || undefined,
+                    filename: asString(action.filename) || asString(action.file_name) || asString(action.name) || asString(action.title) || undefined,
+                    append: action.append === true,
+                });
+            }
+            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;
+            const limit = typeof action.limit === "number" ? Math.max(1, Math.min(5_000, action.limit)) : undefined;
             actions.push({ type: "list_files", path: filePath, limit });
             continue;
         }
@@ -1192,6 +1256,7 @@ export class NativeMacOSJobExecutor {
     lastActiveApp = null;
     lastVisualTargetDescription = null;
     lastVisualTargetApp = null;
+    lastReadFrontmostPage = null;
     lastSatisfiedSpotifyDescription = null;
     lastSatisfiedSpotifyConfirmedPlaying = false;
     lastSatisfiedSpotifyAt = 0;
@@ -1330,6 +1395,10 @@ export class NativeMacOSJobExecutor {
                 if (action.type === "read_frontmost_page") {
                     await reporter.progress(progressPercent, `Lendo a pagina ativa em ${action.app || "Safari"}`);
                     const page = await this.readFrontmostPage(action.app || "Safari");
+                    this.lastReadFrontmostPage = {
+                        app: action.app || "Safari",
+                        ...page,
+                    };
                     if (!page.text && this.bridgeConfig?.apiBaseUrl && this.bridgeConfig?.deviceToken) {
                         await reporter.progress(progressPercent, "Safari bloqueou leitura direta; vou analisar a pagina pela tela");
                         const screenshotPath = await this.takeScreenshot();
@@ -1389,14 +1458,39 @@ export class NativeMacOSJobExecutor {
                 }
                 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}`);
+                    const fileContent = await this.readLocalFileSnapshot(action.path, action.max_chars);
+                    resultPayload.read_file = fileContent;
+                    resultPayload.summary = fileContent.summary;
+                    completionNotes.push(fileContent.summary);
+                    continue;
+                }
+                if (action.type === "trash_path") {
+                    await reporter.progress(progressPercent, `Movendo ${action.path} para a Lixeira`);
+                    const trashed = await this.movePathToTrashSnapshot(action.path);
+                    resultPayload.trash_path = trashed;
+                    resultPayload.summary = trashed.summary;
+                    completionNotes.push(trashed.summary);
+                    continue;
+                }
+                if (action.type === "write_text_file") {
+                    const targetLabel = action.filename ? `${action.path}/${action.filename}` : action.path;
+                    await reporter.progress(progressPercent, `Escrevendo arquivo de texto em ${targetLabel}`);
+                    const resolvedContent = this.resolveWriteTextFileContent(action);
+                    if (!resolvedContent) {
+                        throw new Error("Nenhum texto foi informado para gravar no arquivo local.");
+                    }
+                    const written = await this.writeTextFileSnapshot(action.path, resolvedContent.content, action.filename, action.append === true, resolvedContent.source);
+                    resultPayload.write_text_file = written;
+                    resultPayload.summary = written.summary;
+                    completionNotes.push(written.summary);
                     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}`);
+                    const listing = await this.listLocalFilesSnapshot(action.path, action.limit);
+                    resultPayload.file_listing = listing;
+                    resultPayload.summary = listing.summary;
+                    completionNotes.push(listing.summary);
                     continue;
                 }
                 if (action.type === "count_files") {
@@ -2364,7 +2458,7 @@ return appNames as text
             snapshot.summary = `A pasta ${targetPath} tem ${entries.length} item${entries.length === 1 ? "" : "s"} e ocupa ${formatBytesCompact(totalSize)}.${childPreview ? ` Itens visiveis agora: ${childPreview}.` : ""}`;
             return snapshot;
         }
-        const preview = includePreview ? await this.readLocalFile(resolved, 1200) : undefined;
+        const preview = includePreview ? await this.readLocalFilePreview(resolved, 1200) : undefined;
         const snapshot = {
             captured_at: new Date().toISOString(),
             path: targetPath,
@@ -4573,25 +4667,68 @@ return {
         if (targetApp !== "Safari") {
             throw new Error("Leitura de pagina frontmost esta disponivel apenas para Safari no momento.");
         }
-        const script = `
-tell application "Safari"
-  activate
-  if (count of windows) = 0 then error "Safari nao possui janelas abertas."
-  delay 1
-  set jsCode to "(function(){const title=document.title||'';const url=location.href||'';const text=((document.body&&document.body.innerText)||'').trim().slice(0,12000);const isYouTubeMusic=location.hostname.includes('music.youtube.com');const isSpotify=location.hostname.includes('open.spotify.com');let playerButton=null;let playerTitle='';let playerState='';if(isYouTubeMusic){playerButton=document.querySelector('ytmusic-player-bar #play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button#play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button.play-pause-button');playerTitle=(Array.from(document.querySelectorAll('ytmusic-player-bar .title, ytmusic-player-bar .content-info-wrapper .title, ytmusic-player-bar [slot=title]')).map((node)=>((node&&node.textContent)||'').trim()).find(Boolean))||'';playerState=(playerButton&&((playerButton.getAttribute('title')||playerButton.getAttribute('aria-label')||playerButton.textContent)||'').trim())||'';}else if(isSpotify){const visible=(node)=>{if(!(node instanceof Element))return false;const rect=node.getBoundingClientRect();if(rect.width<4||rect.height<4)return false;const style=window.getComputedStyle(node);if(style.visibility==='hidden'||style.display==='none'||Number(style.opacity||'1')===0)return false;return rect.bottom>=0&&rect.right>=0&&rect.top<=window.innerHeight&&rect.left<=window.innerWidth;};const spotifyTitleCandidates=Array.from(document.querySelectorAll(\"[data-testid='nowplaying-track-link'], footer a[href*='/track/'], [data-testid='now-playing-widget'] a[href*='/track/'], a[href*='/track/']\")).filter((node)=>visible(node)).map((node)=>({node,text:((node&&node.textContent)||'').trim(),rect:node.getBoundingClientRect()})).filter((entry)=>entry.text).sort((left,right)=>{const leftBottomBias=(left.rect.top>=window.innerHeight*0.72?200:0)+(left.rect.left<=window.innerWidth*0.45?120:0)+left.rect.top;const rightBottomBias=(right.rect.top>=window.innerHeight*0.72?200:0)+(right.rect.left<=window.innerWidth*0.45?120:0)+right.rect.top;return rightBottomBias-leftBottomBias;});playerTitle=(spotifyTitleCandidates[0]&&spotifyTitleCandidates[0].text)||'';playerButton=Array.from(document.querySelectorAll(\"footer button, [data-testid='control-button-playpause'], button[aria-label], button[title]\")).filter((node)=>visible(node)).map((node)=>({node,label:((node.getAttribute('aria-label')||node.getAttribute('title')||node.textContent)||'').trim(),rect:node.getBoundingClientRect()})).filter((entry)=>/play|pause|tocar|pausar|reproduzir/i.test(entry.label)).sort((left,right)=>{const leftScore=(left.rect.top>=window.innerHeight*0.72?200:0)+Math.max(0,200-Math.abs((left.rect.left+left.rect.width/2)-(window.innerWidth/2)));const rightScore=(right.rect.top>=window.innerHeight*0.72?200:0)+Math.max(0,200-Math.abs((right.rect.left+right.rect.width/2)-(window.innerWidth/2)));return rightScore-leftScore;})[0]?.node||null;playerState=(playerButton&&((playerButton.getAttribute('aria-label')||playerButton.getAttribute('title')||playerButton.textContent)||'').trim())||'';}return JSON.stringify({title,url,text,playerTitle,playerState});})();"
-  set pageJson to do JavaScript jsCode in current tab of front window
-end tell
-return pageJson
-`;
         try {
-            const { stdout } = await this.runCommandCapture("osascript", ["-e", script]);
-            const parsed = JSON.parse(stdout.trim() || "{}");
+            const page = await this.runSafariJsonScript(`
+const title = document.title || "";
+const url = location.href || "";
+const text = ((document.body && document.body.innerText) || "").trim().slice(0, 12000);
+const isYouTubeMusic = location.hostname.includes("music.youtube.com");
+const isSpotify = location.hostname.includes("open.spotify.com");
+let playerButton = null;
+let playerTitle = "";
+let playerState = "";
+
+if (isYouTubeMusic) {
+  playerButton = document.querySelector("ytmusic-player-bar #play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button#play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button.play-pause-button");
+  playerTitle = (Array.from(document.querySelectorAll("ytmusic-player-bar .title, ytmusic-player-bar .content-info-wrapper .title, ytmusic-player-bar [slot=title]"))
+    .map((node) => ((node && node.textContent) || "").trim())
+    .find(Boolean)) || "";
+  playerState = (playerButton && ((playerButton.getAttribute("title") || playerButton.getAttribute("aria-label") || playerButton.textContent) || "").trim()) || "";
+} else if (isSpotify) {
+  const visible = (node) => {
+    if (!(node instanceof Element)) return false;
+    const rect = node.getBoundingClientRect();
+    if (rect.width < 4 || rect.height < 4) return false;
+    const style = window.getComputedStyle(node);
+    if (style.visibility === "hidden" || style.display === "none" || Number(style.opacity || "1") === 0) return false;
+    return rect.bottom >= 0 && rect.right >= 0 && rect.top <= window.innerHeight && rect.left <= window.innerWidth;
+  };
+  const spotifyTitleCandidates = Array.from(document.querySelectorAll("[data-testid='nowplaying-track-link'], footer a[href*='/track/'], [data-testid='now-playing-widget'] a[href*='/track/'], a[href*='/track/']"))
+    .filter((node) => visible(node))
+    .map((node) => ({ node, text: ((node && node.textContent) || "").trim(), rect: node.getBoundingClientRect() }))
+    .filter((entry) => entry.text)
+    .sort((left, right) => {
+      const leftBottomBias = (left.rect.top >= window.innerHeight * 0.72 ? 200 : 0) + (left.rect.left <= window.innerWidth * 0.45 ? 120 : 0) + left.rect.top;
+      const rightBottomBias = (right.rect.top >= window.innerHeight * 0.72 ? 200 : 0) + (right.rect.left <= window.innerWidth * 0.45 ? 120 : 0) + right.rect.top;
+      return rightBottomBias - leftBottomBias;
+    });
+  playerTitle = (spotifyTitleCandidates[0] && spotifyTitleCandidates[0].text) || "";
+  playerButton = Array.from(document.querySelectorAll("footer button, [data-testid='control-button-playpause'], button[aria-label], button[title]"))
+    .filter((node) => visible(node))
+    .map((node) => ({ node, label: ((node.getAttribute("aria-label") || node.getAttribute("title") || node.textContent) || "").trim(), rect: node.getBoundingClientRect() }))
+    .filter((entry) => /play|pause|tocar|pausar|reproduzir/i.test(entry.label))
+    .sort((left, right) => {
+      const leftScore = (left.rect.top >= window.innerHeight * 0.72 ? 200 : 0) + Math.max(0, 200 - Math.abs((left.rect.left + left.rect.width / 2) - (window.innerWidth / 2)));
+      const rightScore = (right.rect.top >= window.innerHeight * 0.72 ? 200 : 0) + Math.max(0, 200 - Math.abs((right.rect.left + right.rect.width / 2) - (window.innerWidth / 2)));
+      return rightScore - leftScore;
+    })[0]?.node || null;
+  playerState = (playerButton && ((playerButton.getAttribute("aria-label") || playerButton.getAttribute("title") || playerButton.textContent) || "").trim()) || "";
+}
+
+return {
+  title,
+  url,
+  text,
+  playerTitle,
+  playerState,
+};
+        `, {}, { activate: true });
             return {
-                title: asString(parsed.title) || "",
-                url: asString(parsed.url) || "",
-                text: asString(parsed.text) || "",
-                playerTitle: asString(parsed.playerTitle) || "",
-                playerState: asString(parsed.playerState) || "",
+                title: page.title || "",
+                url: page.url || "",
+                text: page.text || "",
+                playerTitle: page.playerTitle || "",
+                playerState: page.playerState || "",
             };
         }
         catch (error) {
@@ -4961,9 +5098,9 @@ if let output = String(data: data, encoding: .utf8) {
             resized,
         };
     }
-    async readLocalFile(filePath, maxChars = 4000) {
-        const resolved = await this.resolveReadableFilePath(filePath);
+    async loadReadableFileContent(resolved) {
         const extension = path.extname(resolved).toLowerCase();
+        const mimeType = mimeTypeFromPath(resolved);
         if (TEXTUTIL_READABLE_EXTENSIONS.has(extension)) {
             const { stdout } = await this.runCommandCapture("textutil", [
                 "-convert",
@@ -4971,17 +5108,263 @@ if let output = String(data: data, encoding: .utf8) {
                 "-stdout",
                 resolved,
             ]);
-            const content = sanitizeTextForJsonTransport(stdout);
-            return clipTextPreview(content || "(arquivo sem texto legivel)", maxChars);
+            return {
+                mimeType,
+                encoding: "utf-8",
+                isBinary: false,
+                content: sanitizeTextForJsonTransport(stdout) || "(arquivo sem texto legivel)",
+            };
         }
         const raw = await readFile(resolved);
         if (isLikelyBinaryBuffer(raw)) {
             const filename = path.basename(resolved);
             const detectedType = extension || "binario";
-            return clipText(`O arquivo ${filename} parece ser binario (${detectedType}) e nao pode ser lido como texto puro pelo Otto Bridge ainda.`, maxChars);
+            return {
+                mimeType,
+                isBinary: true,
+                binaryNotice: `O arquivo ${filename} parece ser binario (${detectedType}) e nao pode ser lido como texto puro pelo Otto Bridge ainda.`,
+            };
+        }
+        return {
+            mimeType,
+            encoding: "utf-8",
+            isBinary: false,
+            content: sanitizeTextForJsonTransport(raw.toString("utf8")) || "(arquivo vazio)",
+        };
+    }
+    async readLocalFilePreview(filePath, maxChars = 1200) {
+        const resolved = await this.resolveReadableFilePath(filePath);
+        const loaded = await this.loadReadableFileContent(resolved);
+        if (loaded.isBinary) {
+            return clipText(loaded.binaryNotice || "O arquivo parece ser binario e nao pode ser lido como texto puro.", maxChars);
+        }
+        return clipTextPreview(loaded.content || "(arquivo vazio)", maxChars);
+    }
+    async readLocalFileSnapshot(filePath, chunkSizeChars = 4000) {
+        const resolved = await this.resolveReadableFilePath(filePath);
+        const entryStat = await stat(resolved);
+        const loaded = await this.loadReadableFileContent(resolved);
+        const fileName = path.basename(resolved) || resolved;
+        if (loaded.isBinary) {
+            return {
+                captured_at: new Date().toISOString(),
+                path: filePath,
+                resolved_path: resolved,
+                name: fileName,
+                mime_type: loaded.mimeType,
+                size_bytes: entryStat.size,
+                modified_at: entryStat.mtime.toISOString(),
+                is_binary: true,
+                binary_notice: loaded.binaryNotice,
+                summary: loaded.binaryNotice || `O arquivo ${filePath} parece ser binario e nao pode ser lido como texto puro.`,
+            };
+        }
+        const content = loaded.content || "(arquivo vazio)";
+        const chunks = chunkTextForTransport(content, chunkSizeChars);
+        return {
+            captured_at: new Date().toISOString(),
+            path: filePath,
+            resolved_path: resolved,
+            name: fileName,
+            mime_type: loaded.mimeType,
+            size_bytes: entryStat.size,
+            modified_at: entryStat.mtime.toISOString(),
+            is_binary: false,
+            encoding: loaded.encoding || "utf-8",
+            content: chunks.length <= 1 ? content : undefined,
+            content_char_count: content.length,
+            chunk_size_chars: Math.max(400, Math.min(Math.round(chunkSizeChars || 4000), 32_000)),
+            chunk_count: chunks.length,
+            chunks,
+            summary: `Li ${filePath} por completo (${content.length} caracteres em ${chunks.length} bloco${chunks.length === 1 ? "" : "s"}).`,
+        };
+    }
+    async resolveTrashTargetPath(targetPath) {
+        const resolved = expandUserPath(targetPath);
+        try {
+            await stat(resolved);
+            return resolved;
+        }
+        catch {
+            // Continue into heuristic search below.
+        }
+        const targetName = path.basename(resolved).trim();
+        if (!targetName || targetName === "." || targetName === path.sep) {
+            return resolved;
         }
-        const content = sanitizeTextForJsonTransport(raw.toString("utf8"));
-        return clipTextPreview(content || "(arquivo vazio)", maxChars);
+        const homeDir = os.homedir();
+        const requestedDir = path.dirname(resolved);
+        const preferredRoots = uniqueStrings([
+            requestedDir && requestedDir !== homeDir ? requestedDir : null,
+            path.join(homeDir, "Downloads"),
+            path.join(homeDir, "Desktop"),
+            path.join(homeDir, "Documents"),
+            homeDir,
+        ]);
+        const found = await this.findPathByName(targetName, preferredRoots);
+        return found || resolved;
+    }
+    async findPathByName(targetName, roots) {
+        const normalizedTarget = normalizeText(targetName).replace(/\s+/g, " ").trim();
+        if (!normalizedTarget) {
+            return null;
+        }
+        for (const root of roots) {
+            let rootStat;
+            try {
+                rootStat = await stat(root);
+            }
+            catch {
+                continue;
+            }
+            if (!rootStat.isDirectory()) {
+                continue;
+            }
+            const queue = [root];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (!current)
+                    continue;
+                let entries;
+                try {
+                    entries = await readdir(current, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const entry of entries) {
+                    const entryPath = path.join(current, entry.name);
+                    const normalizedEntryName = normalizeText(entry.name).replace(/\s+/g, " ").trim();
+                    if (normalizedEntryName === normalizedTarget) {
+                        return entryPath;
+                    }
+                    if (entry.isDirectory()) {
+                        if (!FILE_SEARCH_SKIP_DIRS.has(entry.name)) {
+                            queue.push(entryPath);
+                        }
+                        continue;
+                    }
+                    if (entry.isFile() && entry.name.toLowerCase() === targetName.toLowerCase()) {
+                        return entryPath;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    async resolveUniqueTrashDestination(targetPath) {
+        const ext = path.extname(targetPath);
+        const stem = ext ? targetPath.slice(0, -ext.length) : targetPath;
+        let attempt = 0;
+        let candidate = targetPath;
+        while (true) {
+            try {
+                await stat(candidate);
+                attempt += 1;
+                candidate = `${stem} ${attempt + 1}${ext}`;
+            }
+            catch {
+                return candidate;
+            }
+        }
+    }
+    async movePathToTrashSnapshot(targetPath) {
+        const resolved = await this.resolveTrashTargetPath(targetPath);
+        const entryStat = await stat(resolved);
+        const trashDir = path.join(os.homedir(), ".Trash");
+        await mkdir(trashDir, { recursive: true });
+        const name = path.basename(resolved) || resolved;
+        const trashedPath = await this.resolveUniqueTrashDestination(path.join(trashDir, name));
+        await rename(resolved, trashedPath);
+        const kind = entryStat.isDirectory()
+            ? "directory"
+            : entryStat.isFile()
+                ? "file"
+                : "other";
+        return {
+            captured_at: new Date().toISOString(),
+            path: targetPath,
+            resolved_path: resolved,
+            trashed_path: trashedPath,
+            name,
+            kind,
+            size_bytes: entryStat.size,
+            modified_at: entryStat.mtime.toISOString(),
+            summary: `${kind === "directory" ? "Mandei a pasta" : kind === "file" ? "Mandei o arquivo" : "Mandei o item"} ${name} para a Lixeira.`,
+        };
+    }
+    async resolveWritableTextFilePath(targetPath, filename) {
+        const expanded = expandUserPath(targetPath);
+        const requestedFilename = filename ? sanitizeFileName(filename) : null;
+        if (requestedFilename) {
+            try {
+                const existingStat = await stat(expanded);
+                if (existingStat.isDirectory()) {
+                    return path.join(expanded, requestedFilename);
+                }
+            }
+            catch {
+                // Continue below and treat the target as a direct file path.
+            }
+            if (String(targetPath || "").trimEnd().endsWith(path.sep)) {
+                return path.join(expanded, requestedFilename);
+            }
+        }
+        try {
+            const existingStat = await stat(expanded);
+            if (existingStat.isDirectory()) {
+                return path.join(expanded, sanitizeFileName("otto-note.txt"));
+            }
+        }
+        catch {
+            // Continue below and treat the target as a direct file path.
+        }
+        if (String(targetPath || "").trimEnd().endsWith(path.sep)) {
+            return path.join(expanded, sanitizeFileName("otto-note.txt"));
+        }
+        return expanded;
+    }
+    async writeTextFileSnapshot(targetPath, text, filename, append = false, source) {
+        const resolved = await this.resolveWritableTextFilePath(targetPath, filename);
+        const parentDir = path.dirname(resolved);
+        await mkdir(parentDir, { recursive: true });
+        await writeFile(resolved, text, {
+            encoding: "utf8",
+            flag: append ? "a" : "w",
+        });
+        const entryStat = await stat(resolved);
+        const name = path.basename(resolved) || resolved;
+        const preview = clipTextPreview(String(text || "") || "(arquivo vazio)", 240);
+        return {
+            captured_at: new Date().toISOString(),
+            path: targetPath,
+            resolved_path: resolved,
+            name,
+            mime_type: "text/plain; charset=utf-8",
+            size_bytes: entryStat.size,
+            modified_at: entryStat.mtime.toISOString(),
+            append,
+            content_char_count: String(text || "").length,
+            content_preview: preview,
+            source: source || undefined,
+            summary: `${append ? "Atualizei" : "Escrevi"} ${String(text || "").length} caractere${String(text || "").length === 1 ? "" : "s"} em ${resolved}.`,
+        };
+    }
+    resolveWriteTextFileContent(action) {
+        const explicitText = [action.text, action.content, action.body]
+            .map((value) => String(value || "").trim())
+            .find(Boolean);
+        if (explicitText) {
+            return { content: explicitText };
+        }
+        const source = String(action.source || "").trim().toLowerCase();
+        if (source === "last_page_text" || source === "last_page_summary") {
+            const pageText = String(this.lastReadFrontmostPage?.text || "").trim();
+            if (pageText) {
+                return { content: pageText, source };
+            }
+        }
+        return null;
     }
     async resolveReadableFilePath(filePath) {
         const resolved = expandUserPath(filePath);
@@ -5052,22 +5435,55 @@ if let output = String(data: data, encoding: .utf8) {
         }
         return null;
     }
-    async listLocalFiles(directoryPath, limit = 40) {
+    async listLocalFilesSnapshot(directoryPath, limit) {
         const resolved = expandUserPath(directoryPath);
-        const entries = await readdir(resolved, { withFileTypes: true });
-        const items = await Promise.all(entries.slice(0, limit).map(async (entry) => {
+        const allEntries = await readdir(resolved, { withFileTypes: true });
+        const sortedEntries = allEntries.sort((left, right) => {
+            if (left.isDirectory() !== right.isDirectory()) {
+                return left.isDirectory() ? -1 : 1;
+            }
+            return left.name.localeCompare(right.name);
+        });
+        const effectiveLimit = typeof limit === "number" && Number.isFinite(limit) ? Math.max(1, Math.min(Math.round(limit), 5_000)) : null;
+        const selectedEntries = effectiveLimit ? sortedEntries.slice(0, effectiveLimit) : sortedEntries;
+        const items = await Promise.all(selectedEntries.map(async (entry) => {
             const entryPath = path.join(resolved, entry.name);
-            let suffix = "";
+            let sizeBytes;
+            let modifiedAt;
             try {
                 const entryStat = await stat(entryPath);
-                suffix = entry.isDirectory() ? "/" : ` (${entryStat.size} bytes)`;
+                if (!entry.isDirectory()) {
+                    sizeBytes = entryStat.size;
+                }
+                modifiedAt = entryStat.mtime.toISOString();
             }
             catch {
-                suffix = entry.isDirectory() ? "/" : "";
+                // Ignore stat failures and return the visible entry metadata we have.
             }
-            return `${entry.name}${suffix}`;
+            return {
+                name: entry.name,
+                path: entryPath,
+                kind: entry.isDirectory() ? "directory" : (entry.isFile() ? "file" : "other"),
+                size_bytes: sizeBytes,
+                modified_at: modifiedAt,
+            };
         }));
-        return items.length > 0 ? items.join("\n") : "(pasta vazia)";
+        const summary = items.length === 0
+            ? `A pasta ${directoryPath} esta vazia.`
+            : effectiveLimit && allEntries.length > items.length
+                ? `Listei ${items.length} itens visiveis em ${directoryPath} agora. A pasta tem ${allEntries.length} itens no total.`
+                : `Listei ${items.length} itens de ${directoryPath} por completo.`;
+        return {
+            captured_at: new Date().toISOString(),
+            path: directoryPath,
+            resolved_path: resolved,
+            name: path.basename(resolved) || resolved,
+            item_count: items.length,
+            total_item_count: allEntries.length,
+            limit_applied: effectiveLimit || undefined,
+            entries: items,
+            summary,
+        };
     }
     async countLocalFiles(directoryPath, extensions, recursive = true) {
         const resolved = expandUserPath(directoryPath);
@@ -5410,6 +5826,12 @@ if let output = String(data: data, encoding: .utf8) {
         if (action.type === "read_file") {
             return `${action.path} foi lido no macOS`;
         }
+        if (action.type === "trash_path") {
+            return `${action.path} foi movido para a Lixeira`;
+        }
+        if (action.type === "write_text_file") {
+            return `Arquivo de texto escrito em ${action.filename ? `${action.path}/${action.filename}` : action.path}`;
+        }
         if (action.type === "list_files") {
             return `Arquivos listados em ${action.path}`;
         }

package/dist/tool_catalog.js

@@ -65,6 +65,23 @@ const NATIVE_MACOS_BASE_TOOLS = [
         mode: "observe",
         action_types: ["read_file"],
     },
+    {
+        id: "filesystem.write",
+        title: "Escrita de arquivo de texto",
+        description: "Cria ou atualiza arquivos .txt em caminhos locais, incluindo Desktop e outras pastas do usuario.",
+        category: "filesystem",
+        mode: "write",
+        action_types: ["write_text_file"],
+    },
+    {
+        id: "filesystem.trash",
+        title: "Mover item para a Lixeira",
+        description: "Move arquivos e pastas locais para a Lixeira do macOS com confirmação.",
+        category: "filesystem",
+        mode: "write",
+        action_types: ["trash_path"],
+        requires_confirmation: true,
+    },
     {
         id: "system.health",
         title: "Status do Mac",

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "0.9.0";
+export const BRIDGE_VERSION = "0.9.2";
 export const BRIDGE_PACKAGE_NAME = "@leg3ndy/otto-bridge";
 export const DEFAULT_API_BASE_URL = "http://localhost:8000";
 export const DEFAULT_POLL_INTERVAL_MS = 3000;
@@ -10,4 +10,4 @@ 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;
-export const BRIDGE_LOCAL_TOOLS_VERSION = 1;
+export const BRIDGE_LOCAL_TOOLS_VERSION = 2;

package/package.json

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