primocode 7.3.0 → 7.4.0

package/lib/config.js

@@ -163,6 +163,9 @@ function loadConfig() {
         token: process.env.PRIMOCODE_TOKEN || file.token || null,
         autoApply: file.autoApply === true,
         currentProject: file.currentProject || null,
+        userName: file.userName || null,
+        mascot: file.mascot || 'primo',
+        theme: file.theme || 'primo',
         rootDir: ROOT_DIR,
         _file: file,
     };
@@ -172,8 +175,8 @@ function saveConfig(partial) {
     ensureDir(CONFIG_DIR);
     const cur = (() => { try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return {}; } })();
     // Só persiste o que faz sentido guardar — nada de campos derivados.
-    const { server, model, token, autoApply, currentProject } = { ...cur, ...partial };
-    const next = { server, model, token, autoApply, currentProject };
+    const { server, model, token, autoApply, currentProject, userName, mascot, theme } = { ...cur, ...partial };
+    const next = { server, model, token, autoApply, currentProject, userName, mascot, theme };
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), 'utf8');
     return next;
 }

package/lib/desktop.js

@@ -1,142 +1,189 @@
-/**
- * desktop.js — Controle nativo do mouse/teclado do sistema operacional.
- * Zero dependências npm. Usa ferramentas nativas do SO:
- *   Linux: xdotool
- *   macOS: cliclick (brew install cliclick) ou osascript
- *   Windows: powershell + System.Windows.Forms
- */
-
-'use strict';
-
-const { execSync } = require('child_process');
-const os = require('os');
-
-const PLATFORM = os.platform();
-
-function hasCmd(cmd) {
-    try { execSync(`which ${cmd} || where ${cmd}`, { stdio: 'ignore' }); return true; } catch { return false; }
-}
-
-// Detectar ferramenta disponível
-const TOOLS = {
-    xdotool: PLATFORM === 'linux' && hasCmd('xdotool'),
-    cliclick: PLATFORM === 'darwin' && hasCmd('cliclick'),
-    nircmd: PLATFORM === 'win32' && (() => { try { execSync('where nircmd', {stdio:'ignore'}); return true; } catch { return false; } })(),
-};
-
-function run(cmd) {
-    try { execSync(cmd, { stdio: 'ignore', timeout: 10000 }); return { ok: true }; }
-    catch (e) { return { ok: false, error: e.message }; }
-}
-
-// ── Mouse ─────────────────────────────────────────────
-function click(x, y, button = 'left') {
-    if (TOOLS.xdotool) return run(`xdotool mousemove ${x} ${y} click ${button === 'right' ? 3 : 1}`);
-    if (TOOLS.cliclick) return run(`cliclick c:${x},${y}`);
-    if (PLATFORM === 'win32') {
-        const b = button === 'right' ? 'Right' : 'Left';
-        const ps = `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${x}, ${y}); [System.Windows.Forms.MouseButtons]::${b} -bor 0`;
-        return run(`powershell -Command "${ps}"`);
-    }
-    return { ok: false, error: 'Nenhuma ferramenta de automação encontrada. Instale xdotool (Linux), cliclick (Mac) ou configure o modo browser.' };
-}
-
-function move(x, y) {
-    if (TOOLS.xdotool) return run(`xdotool mousemove ${x} ${y}`);
-    if (TOOLS.cliclick) return run(`cliclick m:${x},${y}`);
-    if (PLATFORM === 'win32') {
-        const ps = `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${x}, ${y})`;
-        return run(`powershell -Command "${ps}"`);
-    }
-    return { ok: false, error: 'Automação não disponível' };
-}
-
-function drag(fromX, fromY, toX, toY) {
-    if (TOOLS.xdotool) {
-        return run(`xdotool mousemove ${fromX} ${fromY} mousedown 1 mousemove ${toX} ${toY} mouseup 1`);
-    }
-    if (TOOLS.cliclick) {
-        return run(`cliclick dd:${fromX},${fromY} du:${toX},${toY}`);
-    }
-    return { ok: false, error: 'Drag não suportado nesta plataforma sem xdotool/cliclick' };
-}
-
-function scroll(dy) {
-    if (TOOLS.xdotool) return run(`xdotool click --repeat ${Math.abs(Math.round(dy / 50))} ${dy > 0 ? 5 : 4}`);
-    if (TOOLS.cliclick) return run(`cliclick scroll:${Math.round(dy / 50)}`);
-    return { ok: false, error: 'Scroll não suportado' };
-}
-
-// ── Teclado ───────────────────────────────────────────
-function type(text) {
-    if (TOOLS.xdotool) return run(`xdotool type --delay 10 '${text.replace(/'/g, "'\''")}'`);
-    if (TOOLS.cliclick) {
-        const safe = text.replace(/"/g, '\\"');
-        return run(`osascript -e 'tell application "System Events" to keystroke "${safe}"'`);
-    }
-    if (PLATFORM === 'win32') {
-        const ps = `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${text.replace(/'/g, "''")}')`;
-        return run(`powershell -Command "${ps}"`);
-    }
-    return { ok: false, error: 'Automação de teclado não disponível' };
-}
-
-function key(name) {
-    const map = {
-        Enter: 'Return', Tab: 'Tab', Escape: 'Escape', Backspace: 'Backspace',
-        ArrowUp: 'Up', ArrowDown: 'Down', ArrowLeft: 'Left', ArrowRight: 'Right',
-        Space: 'space', Delete: 'Delete',
-    };
-    const k = map[name] || name;
-    if (TOOLS.xdotool) return run(`xdotool key ${k}`);
-    if (PLATFORM === 'darwin') return run(`osascript -e 'tell application "System Events" to key code ${k}'`);
-    if (PLATFORM === 'win32') {
-        const ps = `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('{${name.toUpperCase()}}')`;
-        return run(`powershell -Command "${ps}"`);
-    }
-    return { ok: false, error: 'Key não suportado' };
-}
-
-// ── Screenshot ────────────────────────────────────────
-function screenshot(saveTo) {
-    const filename = saveTo || `desktop-${Date.now()}.png`;
-    if (PLATFORM === 'darwin') {
-        return run(`screencapture -x ${filename}`) ? { ok: true, path: filename } : { ok: false, error: 'screencapture falhou' };
-    }
-    if (PLATFORM === 'win32') {
-        const ps = `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('{PRTSC}'); Add-Type -AssemblyName System.Drawing; \$bmp = New-Object System.Drawing.Bitmap([System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Width, [System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Height); \$graphics = [System.Drawing.Graphics]::FromImage(\$bmp); \$graphics.CopyFromScreen([System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Location, [System.Drawing.Point]::Empty, \$bmp.Size); \$bmp.Save('${filename}'); \$graphics.Dispose(); \$bmp.Dispose()`;
-        return run(`powershell -Command "${ps}"`) ? { ok: true, path: filename } : { ok: false, error: 'Screenshot falhou' };
-    }
-    return { ok: false, error: 'Screenshot desktop não suportado nesta plataforma. Instale scrot ou gnome-screenshot.' };
-}
-
-function getScreenSize() {
-    if (PLATFORM === 'win32') {
-        try {
-            const out = execSync(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Size.Width.ToString() + ',' + [System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Size.Height.ToString()"`).toString().trim();
-            const [w, h] = out.split(',').map(Number);
-            return { ok: true, width: w, height: h };
-        } catch { }
-    }
-    if (PLATFORM === 'darwin') {
-        try {
-            const out = execSync(`system_profiler SPDisplaysDataType | grep Resolution`).toString();
-            const m = out.match(/(\d+)\s*x\s*(\d+)/);
-            if (m) return { ok: true, width: parseInt(m[1]), height: parseInt(m[2]) };
-        } catch { }
-    }
-    if (TOOLS.xdotool) {
-        try {
-            const wh = execSync(`xdotool getdisplaygeometry`).toString().trim().split(' ');
-            return { ok: true, width: parseInt(wh[0]), height: parseInt(wh[1]) };
-        } catch { }
-    }
-    return { ok: false, error: 'Não foi possível detectar resolução', width: 1920, height: 1080 };
-}
-
-module.exports = {
-    click, move, drag, scroll,
-    type, key,
-    screenshot, getScreenSize,
-    TOOLS,
-};
+/**
+ * desktop.js — Controle nativo do mouse/teclado do sistema operacional.
+ * Zero dependências npm. Usa ferramentas nativas do SO:
+ *   Linux: xdotool
+ *   macOS: cliclick (brew install cliclick) ou osascript
+ *   Windows: powershell + System.Windows.Forms
+ */
+
+'use strict';
+
+const { execSync } = require('child_process');
+const os = require('os');
+
+const PLATFORM = os.platform();
+
+function hasCmd(cmd) {
+    try { execSync(`which ${cmd} || where ${cmd}`, { stdio: 'ignore' }); return true; } catch { return false; }
+}
+
+// Detectar ferramenta disponível
+const TOOLS = {
+    xdotool: PLATFORM === 'linux' && hasCmd('xdotool'),
+    cliclick: PLATFORM === 'darwin' && hasCmd('cliclick'),
+    nircmd: PLATFORM === 'win32' && (() => { try { execSync('where nircmd', {stdio:'ignore'}); return true; } catch { return false; } })(),
+};
+
+function run(cmd) {
+    try { execSync(cmd, { stdio: 'ignore', timeout: 10000 }); return { ok: true }; }
+    catch (e) { return { ok: false, error: e.message }; }
+}
+
+// PowerShell sem perfil; escapa aspas duplas para caber em -Command "...".
+function pwsh(script) {
+    return run(`powershell -NoProfile -Command "${script.replace(/"/g, '\\"')}"`);
+}
+
+// Clique/scroll de verdade no Windows precisam de mouse_event (user32).
+// A abordagem antiga só posicionava o cursor — nunca clicava.
+const WIN_USER32 = "Add-Type -Name U -Namespace W -MemberDefinition '[DllImport(\\\"user32.dll\\\")] public static extern bool SetCursorPos(int X,int Y); [DllImport(\\\"user32.dll\\\")] public static extern void mouse_event(uint f,uint dx,uint dy,uint d,int e);';";
+
+// Primeira ferramenta cujo comando existe no PATH.
+function firstCmd(list) {
+    for (const c of list) if (hasCmd(c)) return c;
+    return null;
+}
+
+// ── Mouse ─────────────────────────────────────────────
+function click(x, y, button = 'left') {
+    if (TOOLS.xdotool) return run(`xdotool mousemove ${x} ${y} click ${button === 'right' ? 3 : 1}`);
+    if (TOOLS.cliclick) return run(`cliclick c:${x},${y}`);
+    if (PLATFORM === 'win32') {
+        const down = button === 'right' ? '0x0008' : '0x0002';
+        const up = button === 'right' ? '0x0010' : '0x0004';
+        return pwsh(`${WIN_USER32} [W.U]::SetCursorPos(${x},${y}); [W.U]::mouse_event(${down},0,0,0,0); [W.U]::mouse_event(${up},0,0,0,0)`);
+    }
+    return { ok: false, error: 'Nenhuma ferramenta de automação encontrada. Instale xdotool (Linux) ou cliclick (macOS), ou use as tools browser_*.' };
+}
+
+function move(x, y) {
+    if (TOOLS.xdotool) return run(`xdotool mousemove ${x} ${y}`);
+    if (TOOLS.cliclick) return run(`cliclick m:${x},${y}`);
+    if (PLATFORM === 'win32') {
+        return pwsh(`${WIN_USER32} [W.U]::SetCursorPos(${x},${y})`);
+    }
+    return { ok: false, error: 'Automação não disponível' };
+}
+
+function drag(fromX, fromY, toX, toY) {
+    if (TOOLS.xdotool) {
+        return run(`xdotool mousemove ${fromX} ${fromY} mousedown 1 mousemove ${toX} ${toY} mouseup 1`);
+    }
+    if (TOOLS.cliclick) {
+        return run(`cliclick dd:${fromX},${fromY} du:${toX},${toY}`);
+    }
+    return { ok: false, error: 'Drag não suportado nesta plataforma sem xdotool/cliclick' };
+}
+
+function scroll(dy) {
+    if (TOOLS.xdotool) return run(`xdotool click --repeat ${Math.max(1, Math.abs(Math.round(dy / 50)))} ${dy > 0 ? 5 : 4}`);
+    if (TOOLS.cliclick) return run(`cliclick scroll:${Math.round(dy / 50)}`);
+    if (PLATFORM === 'win32') {
+        // Roda do mouse: 120 = um "clique". dy>0 rola para baixo (delta negativo).
+        const delta = -Math.round(dy / 50) * 120;
+        return pwsh(`${WIN_USER32} [W.U]::mouse_event(0x0800,0,0,${delta},0)`);
+    }
+    return { ok: false, error: 'Scroll não suportado nesta plataforma' };
+}
+
+// ── Teclado ───────────────────────────────────────────
+function type(text) {
+    if (TOOLS.xdotool) return run(`xdotool type --delay 10 '${text.replace(/'/g, "'\''")}'`);
+    if (TOOLS.cliclick) {
+        const safe = text.replace(/"/g, '\\"');
+        return run(`osascript -e 'tell application "System Events" to keystroke "${safe}"'`);
+    }
+    if (PLATFORM === 'win32') {
+        const ps = `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${text.replace(/'/g, "''")}')`;
+        return run(`powershell -Command "${ps}"`);
+    }
+    return { ok: false, error: 'Automação de teclado não disponível' };
+}
+
+function key(name) {
+    // xdotool usa nomes; cada SO tem seu dialeto — traduzimos por plataforma.
+    const xmap = {
+        Enter: 'Return', Return: 'Return', Tab: 'Tab', Escape: 'Escape', Esc: 'Escape',
+        Backspace: 'BackSpace', ArrowUp: 'Up', ArrowDown: 'Down', ArrowLeft: 'Left',
+        ArrowRight: 'Right', Space: 'space', Delete: 'Delete',
+    };
+    if (TOOLS.xdotool) return run(`xdotool key ${xmap[name] || name}`);
+
+    if (PLATFORM === 'darwin') {
+        // macOS: key code exige NÚMERO. Mapeamos as teclas comuns.
+        const mac = { Enter: 36, Return: 36, Tab: 48, Escape: 53, Esc: 53, Backspace: 51, Delete: 51, Space: 49, ArrowLeft: 123, ArrowRight: 124, ArrowDown: 125, ArrowUp: 126 };
+        if (mac[name] != null) return run(`osascript -e 'tell application "System Events" to key code ${mac[name]}'`);
+        // Atalho com modificadores, ex "cmd+c": usa keystroke.
+        return run(`osascript -e 'tell application "System Events" to keystroke "${String(name).replace(/"/g, '\\"')}"'`);
+    }
+    if (PLATFORM === 'win32') {
+        const win = { Enter: '{ENTER}', Return: '{ENTER}', Tab: '{TAB}', Escape: '{ESC}', Esc: '{ESC}', Backspace: '{BACKSPACE}', Delete: '{DEL}', Space: ' ', ArrowUp: '{UP}', ArrowDown: '{DOWN}', ArrowLeft: '{LEFT}', ArrowRight: '{RIGHT}' };
+        const seq = win[name] || name;
+        return pwsh(`Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${seq.replace(/'/g, "''")}')`);
+    }
+    return { ok: false, error: 'Key não suportado nesta plataforma' };
+}
+
+// ── Screenshot ────────────────────────────────────────
+function screenshot(saveTo) {
+    const filename = saveTo || `desktop-${Date.now()}.png`;
+    const done = (r) => (r.ok ? { ok: true, path: filename, bytes: sizeOf(filename) } : r);
+
+    if (PLATFORM === 'darwin') {
+        return done(run(`screencapture -x "${filename}"`));
+    }
+    if (PLATFORM === 'win32') {
+        const ps = `Add-Type -AssemblyName System.Drawing; Add-Type -AssemblyName System.Windows.Forms; $b=[System.Windows.Forms.Screen]::PrimaryScreen.Bounds; $bmp=New-Object System.Drawing.Bitmap($b.Width,$b.Height); $g=[System.Drawing.Graphics]::FromImage($bmp); $g.CopyFromScreen($b.Location,[System.Drawing.Point]::Empty,$bmp.Size); $bmp.Save('${filename}'); $g.Dispose(); $bmp.Dispose()`;
+        return done(pwsh(ps));
+    }
+    // Linux: tenta as ferramentas comuns, na ordem.
+    const scrot = firstCmd(['scrot', 'gnome-screenshot', 'spectacle', 'import', 'maim']);
+    if (scrot === 'scrot') return done(run(`scrot -o "${filename}"`));
+    if (scrot === 'maim') return done(run(`maim "${filename}"`));
+    if (scrot === 'gnome-screenshot') return done(run(`gnome-screenshot -f "${filename}"`));
+    if (scrot === 'spectacle') return done(run(`spectacle -b -n -o "${filename}"`));
+    if (scrot === 'import') return done(run(`import -window root "${filename}"`)); // ImageMagick
+    return { ok: false, error: 'Screenshot indisponível no Linux. Instale scrot, gnome-screenshot, spectacle, maim ou ImageMagick (import).' };
+}
+
+function sizeOf(f) {
+    try { return require('fs').statSync(f).size; } catch { return 0; }
+}
+
+function getScreenSize() {
+    if (PLATFORM === 'win32') {
+        try {
+            const out = execSync(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Size.Width.ToString() + ',' + [System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Size.Height.ToString()"`).toString().trim();
+            const [w, h] = out.split(',').map(Number);
+            return { ok: true, width: w, height: h };
+        } catch { }
+    }
+    if (PLATFORM === 'darwin') {
+        try {
+            const out = execSync(`system_profiler SPDisplaysDataType | grep Resolution`).toString();
+            const m = out.match(/(\d+)\s*x\s*(\d+)/);
+            if (m) return { ok: true, width: parseInt(m[1]), height: parseInt(m[2]) };
+        } catch { }
+    }
+    if (TOOLS.xdotool) {
+        try {
+            const wh = execSync(`xdotool getdisplaygeometry`).toString().trim().split(' ');
+            return { ok: true, width: parseInt(wh[0]), height: parseInt(wh[1]) };
+        } catch { }
+    }
+    if (PLATFORM === 'linux') {
+        try {
+            const out = execSync(`xrandr --current 2>/dev/null | grep '\\*' | head -1`).toString();
+            const m = out.match(/(\d+)\s*x\s*(\d+)/);
+            if (m) return { ok: true, width: parseInt(m[1]), height: parseInt(m[2]) };
+        } catch { }
+    }
+    return { ok: false, error: 'Não foi possível detectar resolução', width: 1920, height: 1080 };
+}
+
+module.exports = {
+    click, move, drag, scroll,
+    type, key,
+    screenshot, getScreenSize,
+    TOOLS,
+};

package/lib/tools.js

@@ -11,6 +11,8 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { exec } = require('child_process');
+const browser = require('./browser');
+const desktop = require('./desktop');
 
 const IGNORAR = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache', 'vendor']);
 const MAX_ARQUIVOS_VARREDURA = 5000;
@@ -26,6 +28,11 @@ function fmtBytes(n) {
 // "../../.." viraria escrita fora da área do projeto.
 function resolveInProject(rawPath, projectDir) {
     const base = projectDir || process.cwd();
+    // Letra de drive (C:\, D:/) é sempre absoluta — mesmo no Linux, onde o
+    // path.resolve a trataria como nome relativo e deixaria escapar da pasta.
+    if (/^[a-zA-Z]:[\\/]/.test(String(rawPath || ''))) {
+        throw new Error(`Caminho fora da pasta de trabalho: ${rawPath}`);
+    }
     const target = path.resolve(base, rawPath || '.');
     const rel = path.relative(base, target);
     if (rel.startsWith('..') || path.isAbsolute(rel)) {
@@ -259,6 +266,57 @@ function readFile({ path: rawPath, offset, limit }, projectDir) {
     return { ok: true, content: recorte, linhas: todas.length, de: inicio + 1, ate: fim, bytes: bruto.length };
 }
 
+// ── multi_edit: várias trocas no mesmo arquivo, em ordem, tudo-ou-nada ────
+function multiEdit({ path: rawPath, edits }, projectDir) {
+    const filePath = resolveInProject(rawPath, projectDir);
+    if (!fs.existsSync(filePath)) return { ok: false, error: `Arquivo não existe: ${rawPath}` };
+    if (!Array.isArray(edits) || !edits.length) return { ok: false, error: 'edits (lista) é obrigatório' };
+
+    let conteudo = fs.readFileSync(filePath, 'utf-8');
+    const linhasAntes = conteudo.split('\n').length;
+    let substituicoes = 0;
+
+    for (let i = 0; i < edits.length; i++) {
+        const { old_string, new_string, replace_all } = edits[i] || {};
+        if (typeof old_string !== 'string' || !old_string) return { ok: false, error: `edit ${i + 1}: old_string é obrigatório` };
+        if (old_string === new_string) return { ok: false, error: `edit ${i + 1}: old_string e new_string são iguais` };
+        const ocorrencias = conteudo.split(old_string).length - 1;
+        if (ocorrencias === 0) {
+            return { ok: false, error: `edit ${i + 1}: trecho não encontrado`, trechosParecidos: trechosParecidos(conteudo, old_string) };
+        }
+        if (ocorrencias > 1 && !replace_all) {
+            return { ok: false, error: `edit ${i + 1}: trecho aparece ${ocorrencias}x — use replace_all ou inclua mais contexto para torná-lo único` };
+        }
+        conteudo = replace_all ? conteudo.split(old_string).join(new_string) : conteudo.replace(old_string, new_string);
+        substituicoes++;
+    }
+
+    fs.writeFileSync(filePath, conteudo, 'utf-8');
+    return {
+        ok: true,
+        path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
+        substituicoes,
+        linhasAntes,
+        linhasDepois: conteudo.split('\n').length,
+    };
+}
+
+// ── write_todos: lista de tarefas da sessão (estilo Claude Code) ──────────
+// Só estado + exibição — não chama nada externo. O agente planeja em voz alta
+// e o usuário acompanha o progresso.
+let TODOS = [];
+function writeTodos({ todos }) {
+    if (!Array.isArray(todos)) return { ok: false, error: 'todos (lista) é obrigatório' };
+    const status = new Set(['pending', 'in_progress', 'completed']);
+    TODOS = todos.map((t) => ({
+        content: String((t && (t.content || t.task || t.text)) || '').trim(),
+        status: status.has(t && t.status) ? t.status : 'pending',
+    })).filter((t) => t.content);
+    const feitos = TODOS.filter((t) => t.status === 'completed').length;
+    return { ok: true, todos: TODOS, total: TODOS.length, feitos };
+}
+function getTodos() { return TODOS; }
+
 async function execute(name, args, ctx) {
     const projectDir = (ctx && ctx.projectDir) || process.cwd();
     args = args || {};
@@ -295,6 +353,60 @@ async function execute(name, args, ctx) {
                     : resolveInProject(args.target, projectDir);
                 return openInBrowser(alvo);
             }
+            case 'multi_edit':
+                return multiEdit(args, projectDir);
+            case 'write_todos':
+                return writeTodos(args);
+
+            // ── Navegador controlado (CDP) — o agente age numa página real ──
+            case 'browser_open': {
+                const alvo = /^https?:\/\//i.test(args.url || '')
+                    ? args.url
+                    : 'file://' + resolveInProject(args.url, projectDir);
+                return browser.open(alvo);
+            }
+            case 'browser_click':
+                if (args.selector) return browser.clickSelector(args.selector);
+                if (args.text) return browser.clickText(args.text);
+                if (args.x != null && args.y != null) return browser.click(args.x, args.y);
+                return { ok: false, error: 'browser_click precisa de selector, text ou x/y' };
+            case 'browser_type':
+                if (args.selector) return browser.typeInSelector(args.selector, args.text || '', args.clear !== false);
+                return browser.type(args.text || '');
+            case 'browser_key':
+                return browser.key(args.key);
+            case 'browser_read': {
+                const sel = args.selector ? `document.querySelector(${JSON.stringify(args.selector)})` : 'document.body';
+                const texto = await browser.evaluate(`(function(){const e=${sel};return e?e.innerText.slice(0,6000):null;})()`);
+                return texto == null ? { ok: false, error: 'nada na página (ou seletor não encontrado)' } : { ok: true, text: texto };
+            }
+            case 'browser_screenshot':
+                return browser.screenshot(args.path ? resolveInProject(args.path, projectDir) : undefined);
+            case 'browser_scroll':
+                return browser.scroll(args.dy != null ? args.dy : 600);
+            case 'browser_wait':
+                return browser.waitFor(args.selector, args.timeout_ms || 15000);
+            case 'browser_eval':
+                return { ok: true, value: await browser.evaluate(args.js || 'null') };
+
+            // ── Desktop físico — mouse, teclado e tela do usuário ───────────
+            case 'desktop_screenshot':
+                return desktop.screenshot(args.path ? resolveInProject(args.path, projectDir) : undefined);
+            case 'desktop_click':
+                return desktop.click(args.x, args.y, args.button || 'left');
+            case 'desktop_move':
+                return desktop.move(args.x, args.y);
+            case 'desktop_drag':
+                return desktop.drag(args.from_x, args.from_y, args.to_x, args.to_y);
+            case 'desktop_type':
+                return desktop.type(args.text || '');
+            case 'desktop_key':
+                return desktop.key(args.key);
+            case 'desktop_scroll':
+                return desktop.scroll(args.dy != null ? args.dy : 300);
+            case 'desktop_size':
+                return desktop.getScreenSize();
+
             default:
                 return { ok: false, error: `Tool não implementada: ${name}` };
         }
@@ -340,4 +452,5 @@ async function uninstall() {
 module.exports = {
     fmtBytes, treeDir, applyCodeBlocks, runShell, openInBrowser, runInNewTerminal,
     execute, uninstall, resolveInProject, globToRegex, globFiles, grepFiles, editFile,
+    multiEdit, writeTodos, getTodos,
 };