chocolatito-code 1.0.0

package/dist/tools/browserLive.js

@@ -0,0 +1,265 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import puppeteer from "puppeteer";
+import { execa } from "execa";
+let globalBrowser = null;
+let globalPage = null;
+let consoleLogs = [];
+let networkErrors = [];
+export async function browserLive(params, cwd = process.cwd()) {
+    const { action, url, selector, text, script, outputPath, headless = false, profileDirectory } = params;
+    try {
+        // 0. Handle open_system: Opens the URL directly in the user's real Chrome profile without guest isolation
+        if (action === "open_system") {
+            const targetUrl = url || "https://labs.google/fx/tools/flow";
+            const profile = profileDirectory || "Profile 1"; // Profile 1 is the main user profile with active Google session
+            try {
+                if (process.platform === "win32") {
+                    execa("cmd.exe", ["/c", "start", "", "chrome.exe", `--profile-directory=${profile}`, targetUrl], {
+                        detached: true,
+                        stdio: "ignore",
+                    }).unref();
+                }
+                else if (process.platform === "darwin") {
+                    execa("open", ["-a", "Google Chrome", "--args", `--profile-directory=${profile}`, targetUrl], {
+                        detached: true,
+                        stdio: "ignore",
+                    }).unref();
+                }
+                else {
+                    execa("google-chrome", [`--profile-directory=${profile}`, targetUrl], {
+                        detached: true,
+                        stdio: "ignore",
+                    }).unref();
+                }
+                return `✔ URL "${targetUrl}" abierta de forma segura en Chrome con el perfil "${profile}".`;
+            }
+            catch (err) {
+                return `Fallo al abrir Chrome del sistema: ${err?.message || String(err)}`;
+            }
+        }
+        // 1. Ensure persistent browser profile directory exists
+        const persistentDataDir = params.userDataDir || path.join(os.homedir(), ".chocolatito", "browser-data");
+        if (!fs.existsSync(persistentDataDir)) {
+            fs.mkdirSync(persistentDataDir, { recursive: true });
+        }
+        // 2. Ensure browser is open if needed
+        if (action !== "close" && (!globalBrowser || !globalBrowser.connected)) {
+            consoleLogs = [];
+            networkErrors = [];
+            const launchArgs = [
+                "--no-sandbox",
+                "--disable-setuid-sandbox",
+                "--start-maximized",
+            ];
+            if (profileDirectory) {
+                launchArgs.push(`--profile-directory=${profileDirectory}`);
+            }
+            try {
+                globalBrowser = await puppeteer.launch({
+                    headless: headless ? "shell" : false,
+                    userDataDir: persistentDataDir,
+                    defaultViewport: null,
+                    args: launchArgs,
+                });
+            }
+            catch {
+                globalBrowser = await puppeteer.launch({
+                    channel: "chrome",
+                    headless: headless ? "shell" : false,
+                    userDataDir: persistentDataDir,
+                    defaultViewport: null,
+                    args: launchArgs,
+                });
+            }
+            const pages = await globalBrowser.pages();
+            globalPage = pages.length > 0 ? pages[0] : await globalBrowser.newPage();
+            globalPage.on("console", (msg) => {
+                consoleLogs.push({
+                    type: msg.type(),
+                    text: msg.text(),
+                    time: new Date().toLocaleTimeString(),
+                });
+            });
+            globalPage.on("pageerror", (err) => {
+                consoleLogs.push({
+                    type: "error",
+                    text: `[Page Error]: ${err?.message || String(err)}`,
+                    time: new Date().toLocaleTimeString(),
+                });
+            });
+            globalPage.on("requestfailed", (req) => {
+                networkErrors.push(`[${req.method()}] ${req.url()} - ${req.failure()?.errorText || "FAILED"}`);
+            });
+        }
+        // 3. Dispatch specific browser actions
+        switch (action) {
+            case "launch": {
+                const target = url || "http://localhost:3000";
+                await globalPage.goto(target, { waitUntil: "domcontentloaded", timeout: 20_000 });
+                const title = await globalPage.title();
+                return `✔ Navegador en vivo iniciado en "${target}" (Título: "${title}").`;
+            }
+            case "navigate": {
+                if (!url)
+                    return "Error: Se requiere 'url' para navegar.";
+                await globalPage.goto(url, { waitUntil: "domcontentloaded", timeout: 25_000 });
+                const title = await globalPage.title();
+                return `✔ Navegador en tiempo real abierto en "${url}" (Título: "${title}").`;
+            }
+            case "click": {
+                if (!selector)
+                    return "Error: Se requiere un 'selector' CSS o texto para hacer clic.";
+                await globalPage.waitForSelector(selector, { timeout: 8_000 });
+                // Inject visual click ripple in the DOM
+                await globalPage.evaluate((sel) => {
+                    // @ts-ignore
+                    const el = document.querySelector(sel);
+                    if (el) {
+                        const rect = el.getBoundingClientRect();
+                        // @ts-ignore
+                        const dot = document.createElement("div");
+                        dot.style.position = "fixed";
+                        dot.style.left = `${rect.left + rect.width / 2 - 16}px`;
+                        dot.style.top = `${rect.top + rect.height / 2 - 16}px`;
+                        dot.style.width = "32px";
+                        dot.style.height = "32px";
+                        dot.style.borderRadius = "50%";
+                        dot.style.background = "rgba(235, 87, 87, 0.5)";
+                        dot.style.border = "3px solid #EB5757";
+                        dot.style.boxShadow = "0 0 16px #A855F7";
+                        dot.style.zIndex = "2147483647";
+                        dot.style.pointerEvents = "none";
+                        dot.style.transition = "transform 0.4s ease-out, opacity 0.4s ease-out";
+                        // @ts-ignore
+                        document.body.appendChild(dot);
+                        setTimeout(() => {
+                            dot.style.transform = "scale(2.2)";
+                            dot.style.opacity = "0";
+                        }, 30);
+                        setTimeout(() => dot.remove(), 450);
+                    }
+                }, selector);
+                await globalPage.click(selector);
+                return `✔ Clic ejecutado sobre "${selector}" con efecto visual de cursor activo.`;
+            }
+            case "type": {
+                if (!selector || text === undefined)
+                    return "Error: Se requiere 'selector' y 'text'.";
+                await globalPage.waitForSelector(selector, { timeout: 8_000 });
+                // Highlight input field
+                await globalPage.evaluate((sel) => {
+                    const el = document.querySelector(sel);
+                    if (el) {
+                        el.style.outline = "3px solid #EB5757";
+                        el.style.boxShadow = "0 0 12px rgba(235, 87, 87, 0.6)";
+                    }
+                }, selector);
+                await globalPage.type(selector, text);
+                return `✔ Texto "${text}" escrito en "${selector}".`;
+            }
+            case "screenshot": {
+                const cacheDir = path.join(os.homedir(), ".chocolatito", "cache");
+                if (!fs.existsSync(cacheDir))
+                    fs.mkdirSync(cacheDir, { recursive: true });
+                const out = outputPath
+                    ? (path.isAbsolute(outputPath) ? outputPath : path.resolve(cwd, outputPath))
+                    : path.join(cacheDir, "browser_latest.png");
+                const outDir = path.dirname(out);
+                if (!fs.existsSync(outDir))
+                    fs.mkdirSync(outDir, { recursive: true });
+                // Inject visible glowing mouse cursor indicator in DOM
+                await globalPage.evaluate(() => {
+                    let cursor = document.getElementById("__chocolatito_cursor__");
+                    if (!cursor) {
+                        cursor = document.createElement("div");
+                        cursor.id = "__chocolatito_cursor__";
+                        cursor.style.position = "fixed";
+                        cursor.style.width = "30px";
+                        cursor.style.height = "30px";
+                        cursor.style.borderRadius = "50%";
+                        cursor.style.border = "3px solid #EB5757";
+                        cursor.style.backgroundColor = "rgba(255, 120, 80, 0.45)";
+                        cursor.style.boxShadow = "0 0 12px #EB5757";
+                        cursor.style.pointerEvents = "none";
+                        cursor.style.zIndex = "2147483647";
+                        cursor.style.transform = "translate(-50%, -50%)";
+                        cursor.style.top = "50%";
+                        cursor.style.left = "50%";
+                        document.body.appendChild(cursor);
+                    }
+                });
+                await globalPage.screenshot({ path: out, fullPage: false });
+                const displayPath = outputPath ? path.relative(cwd, out) || out : out;
+                return `✔ Captura en vivo del navegador guardada con cursor visible en "${displayPath}" (${(fs.statSync(out).size / 1024).toFixed(1)} KB).`;
+            }
+            case "evaluate": {
+                if (!script)
+                    return "Error: Se requiere un 'script' JavaScript para evaluar en la consola.";
+                const result = await globalPage.evaluate((code) => {
+                    try {
+                        // @ts-ignore
+                        return window.eval(code);
+                    }
+                    catch (e) {
+                        return `Error JS: ${e?.message || String(e)}`;
+                    }
+                }, script);
+                return `✔ Salida de consola JS:\n${typeof result === "object" ? JSON.stringify(result, null, 2) : String(result)}`;
+            }
+            case "get_interactive_elements": {
+                const elements = await globalPage.evaluate(() => {
+                    const res = [];
+                    const candidates = document.querySelectorAll("button, a, input, textarea, [role='button']");
+                    candidates.forEach((el) => {
+                        const rect = el.getBoundingClientRect();
+                        if (rect.width > 0 && rect.height > 0 && rect.top >= 0) {
+                            const text = (el.textContent || el.value || el.placeholder || "").trim().slice(0, 40);
+                            const tag = el.tagName.toLowerCase();
+                            const id = el.id ? `#${el.id}` : "";
+                            const cls = el.className && typeof el.className === "string" ? `.${el.className.trim().split(/\s+/)[0]}` : "";
+                            const selector = id || `${tag}${cls}` || tag;
+                            res.push({ tag, text, selector, rect: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) } });
+                        }
+                    });
+                    return res.slice(0, 25);
+                });
+                const list = elements.map((e) => `- [${e.tag}] "${e.text}" -> Selector: \`${e.selector}\` en (X: ${e.rect.x + Math.round(e.rect.width / 2)}, Y: ${e.rect.y + Math.round(e.rect.height / 2)})`).join("\n");
+                return `--- ELEMENTOS INTERACTIVOS DETECTADOS ---\n${list || "No se encontraron elementos interactivos visibles."}`;
+            }
+            case "get_console_logs": {
+                const recentLogs = consoleLogs.slice(-20);
+                const recentErrors = networkErrors.slice(-10);
+                if (recentLogs.length === 0 && recentErrors.length === 0) {
+                    return "Consola del navegador limpia: Sin errores ni logs registrados.";
+                }
+                const logLines = recentLogs.map((l) => `[${l.time}] [${l.type.toUpperCase()}] ${l.text}`).join("\n");
+                const errLines = recentErrors.length > 0 ? `\n\nErrores de Red:\n${recentErrors.join("\n")}` : "";
+                return `--- REGISTRO DE CONSOLA Y DEPURACIÓN EN VIVO ---\n${logLines}${errLines}`;
+            }
+            case "get_content": {
+                const textContent = await globalPage.evaluate(() => {
+                    // @ts-ignore
+                    return document.body.innerText;
+                });
+                const title = await globalPage.title();
+                const url = globalPage.url();
+                return `Página: "${title}" (${url})\n\nContenido visible:\n${textContent.slice(0, 5_000)}`;
+            }
+            case "close": {
+                if (globalBrowser) {
+                    await globalBrowser.close();
+                    globalBrowser = null;
+                    globalPage = null;
+                }
+                return "✔ Navegador cerrado exitosamente.";
+            }
+            default:
+                return `Acción no reconocida: ${action}`;
+        }
+    }
+    catch (err) {
+        return `Error en control de navegador (${action}): ${err?.message || String(err)}`;
+    }
+}

package/dist/tools/changeDir.d.ts

@@ -0,0 +1,5 @@
+export declare function changeDir(targetPath: string, currentCwd?: string): Promise<{
+    success: boolean;
+    newCwd: string;
+    message: string;
+}>;

package/dist/tools/changeDir.js

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import fg from "fast-glob";
+export async function changeDir(targetPath, currentCwd = process.cwd()) {
+    const home = os.homedir();
+    const cleanedTarget = targetPath.trim().replace(/^['"]|['"]$/g, "");
+    // 1. Direct candidates
+    const candidates = [
+        path.isAbsolute(cleanedTarget) ? cleanedTarget : path.resolve(currentCwd, cleanedTarget),
+        path.join(home, "Documents", cleanedTarget),
+        path.join(home, "Desktop", cleanedTarget),
+        path.join(home, "Downloads", cleanedTarget),
+        path.join(home, cleanedTarget),
+        path.resolve(currentCwd, "..", cleanedTarget),
+    ];
+    for (const cand of candidates) {
+        if (fs.existsSync(cand)) {
+            try {
+                const stat = fs.statSync(cand);
+                if (stat.isDirectory()) {
+                    process.chdir(cand);
+                    return {
+                        success: true,
+                        newCwd: cand,
+                        message: `Directorio de trabajo cambiado a: "${cand}"`,
+                    };
+                }
+            }
+            catch { }
+        }
+    }
+    // 2. Deep search in user profile if not found directly
+    try {
+        const baseName = path.basename(cleanedTarget);
+        const searchRoots = [home, "C:\\", currentCwd];
+        for (const root of searchRoots) {
+            if (!fs.existsSync(root))
+                continue;
+            const matches = await fg([`**/${baseName}`], {
+                cwd: root,
+                onlyDirectories: true,
+                deep: 4,
+                ignore: ["**/node_modules/**", "**/.git/**", "**/AppData/**", "**/Windows/**"],
+            });
+            if (matches.length > 0) {
+                const bestMatch = path.resolve(root, matches[0]);
+                process.chdir(bestMatch);
+                return {
+                    success: true,
+                    newCwd: bestMatch,
+                    message: `Directorio localizado y cambiado a: "${bestMatch}"`,
+                };
+            }
+        }
+    }
+    catch { }
+    return {
+        success: false,
+        newCwd: currentCwd,
+        message: `Error: No se pudo localizar el directorio "${targetPath}".`,
+    };
+}

package/dist/tools/computerUse.d.ts

@@ -0,0 +1,58 @@
+/**
+ * COMPUTER USE
+ *
+ * Rediseno completo. Los cuatro fallos de la version anterior eran:
+ *
+ *  1. Coordenadas desviadas por DPI. Windows reportaba la pantalla escalada
+ *     (2048x1152 en un monitor de 2560x1440 al 125%) mientras el raton se movia
+ *     en pixeles fisicos. Todo clic caia ~25% arriba-izquierda. El host nuevo se
+ *     declara DPI-aware antes de medir nada, asi que hay un unico sistema de
+ *     coordenadas.
+ *
+ *  2. Ceguera. Se tomaba una captura y el modelo solo recibia "captura guardada,
+ *     340 KB". Sin ver nada, tiraba de coordenadas fijas escritas a mano en el
+ *     prompt. Ahora hay dos formas de saber que hay en pantalla de verdad:
+ *     ui_snapshot (arbol de accesibilidad, texto exacto) y screenshot (que pasa
+ *     por el modelo de vision y vuelve como descripcion).
+ *
+ *  3. Lentitud. Un powershell.exe nuevo con Add-Type por accion, ~1s cada uno.
+ *     Ahora hay un host persistente y cada accion cuesta milisegundos.
+ *
+ *  4. Robo de pantalla. Todo pasaba por el primer plano, con un overlay que se
+ *     dibujaba encima y a veces se quedaba pegado. Ahora el modo por defecto es
+ *     "background": se actua sobre una ventana concreta sin traerla al frente y
+ *     sin mover el raton del usuario.
+ */
+export type ComputerAction = "screenshot" | "ui_snapshot" | "ui_click" | "ui_type" | "ui_focus" | "find_element" | "left_click" | "click" | "double_click" | "triple_click" | "right_click" | "middle_click" | "mouse_move" | "move" | "left_click_drag" | "scroll" | "type" | "key" | "hotkey" | "wait" | "sleep" | "cursor_position" | "list_windows" | "focus_window" | "get_active_window" | "open_app";
+export interface ComputerUseParams {
+    action: ComputerAction;
+    /** Ventana objetivo por titulo o proceso (ej. "chrome", "Flow"). */
+    window?: string;
+    /** "background" (por defecto): no roba el foco. "foreground": raton real. */
+    mode?: "background" | "foreground";
+    ref?: number;
+    /** Solo ui_type: true sustituye todo el contenido del control. Por defecto inserta. */
+    replace?: boolean;
+    coordinate?: [number, number];
+    start_coordinate?: [number, number];
+    x?: number;
+    y?: number;
+    text?: string;
+    keys?: string;
+    key?: string;
+    query?: string;
+    filter?: string;
+    direction?: "up" | "down" | "left" | "right";
+    amount?: number;
+    repeat?: number;
+    ms?: number;
+    seconds?: number;
+    max?: number;
+    outputPath?: string;
+    appName?: string;
+    /** Solo para screenshot: pregunta concreta para el modelo de vision. */
+    question?: string;
+    /** Solo para screenshot: pone false para saltarse la vision y ahorrar tokens. */
+    analyze?: boolean;
+}
+export declare function computerUse(params: ComputerUseParams, cwd?: string, apiKey?: string): Promise<string>;