@johpaz/hive-sdk 0.0.12 → 0.0.15

package/packages/core/src/tools/web/browser-click.ts

@@ -0,0 +1,78 @@
+/**
+ * browser_click - Click on a web page element
+ *
+ * @category web
+ * @seedId browser_click
+ * @spanish hacer clic, botón, enlace, interactuar
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { getBrowserService } from "./browser-service.ts";
+
+const log = logger.child("browser-click");
+
+export const browserClickTool: Tool = {
+  name: "browser_click",
+  description: "Click on a web page element. Spanish: hacer clic, botón, enlace, interactuar",
+  parameters: {
+    type: "object",
+    properties: {
+      selector: {
+        type: "string",
+        description: "CSS selector of the element to click",
+      },
+      url: {
+        type: "string",
+        description: "URL to navigate to before clicking (optional)",
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (default: 30000)",
+      },
+    },
+    required: ["selector"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const selector = params.selector as string;
+    const url = params.url as string | undefined;
+    const timeout = (params.timeout as number) ?? 30000;
+
+    const browserService = getBrowserService();
+    if (!browserService?.isAvailable()) {
+      log.warn("Browser not available");
+      return {
+        ok: false,
+        error: "Browser automation not available. Install Chrome/Chromium.",
+      };
+    }
+
+    log.info(`Clicking: ${selector}${url ? ` on ${url}` : ""}`);
+
+    try {
+      const view = await browserService.getView();
+      if (!view) return { ok: false, error: "Browser automation not available. Install Chrome/Chromium." };
+
+      if (url) {
+        await view.navigate(url);
+        await Bun.sleep(500);
+      }
+
+      // click(selector) already waits for element actionability
+      await view.click(selector, { timeout });
+
+      const currentUrl = view.url;
+      log.info(`Click successful: ${selector} on ${currentUrl}`);
+
+      return {
+        ok: true,
+        message: `Successfully clicked element: ${selector}`,
+        selector,
+        url: currentUrl,
+      };
+    } catch (error) {
+      log.error(`Click failed: ${(error as Error).message}`);
+      return { ok: false, error: `Failed to click: ${(error as Error).message}` };
+    }
+  },
+};

package/packages/core/src/tools/web/browser-extract.ts

@@ -0,0 +1,139 @@
+/**
+ * browser_extract - Extract data from web page using selectors
+ *
+ * @category web
+ * @seedId browser_extract
+ * @spanish extraer datos, obtener información, scraping, selectores
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { getBrowserService, waitForSelector, waitForCondition } from "./browser-service.ts";
+
+const log = logger.child("browser-extract");
+
+export const browserExtractTool: Tool = {
+  name: "browser_extract",
+  description: "Extract text, links, or structured data from page using CSS selectors or XPath. Spanish: extraer datos, obtener información, scraping, selectores",
+  parameters: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "URL to navigate to before extraction (optional)",
+      },
+      selector: {
+        type: "string",
+        description: "CSS selector or XPath (prefix with 'xpath:') to match elements",
+      },
+      attribute: {
+        type: "string",
+        description: "Attribute to extract (href, src, alt, text, innerHTML). Default: text",
+      },
+      all: {
+        type: "boolean",
+        description: "Extract all matches (default: true) or just first (false)",
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (default: 30000)",
+      },
+    },
+    required: ["selector"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const url = params.url as string | undefined;
+    const selector = params.selector as string;
+    const attribute = (params.attribute as string) ?? "text";
+    const all = (params.all as boolean) ?? true;
+    const timeout = (params.timeout as number) ?? 30000;
+
+    const browserService = getBrowserService();
+    if (!browserService?.isAvailable()) {
+      log.warn("Browser not available");
+      return {
+        ok: false,
+        error: "Browser automation not available. Install Chrome/Chromium.",
+      };
+    }
+
+    log.info(`Extracting: ${selector}${url ? ` from ${url}` : ""}`);
+
+    try {
+      const view = await browserService.getView();
+      if (!view) return { ok: false, error: "Browser automation not available. Install Chrome/Chromium." };
+
+      if (url) {
+        await view.navigate(url);
+        await Bun.sleep(500);
+      }
+
+      const isXPath = selector.startsWith("xpath:");
+      const actualSelector = isXPath ? selector.slice(6) : selector;
+
+      // Esperar el elemento — si no aparece, continuar igual
+      try {
+        if (isXPath) {
+          const xpathExpr = `(() => {
+            const r = document.evaluate(
+              ${JSON.stringify(actualSelector)}, document, null,
+              XPathResult.FIRST_ORDERED_NODE_TYPE, null
+            );
+            return r.singleNodeValue !== null;
+          })()`;
+          await waitForCondition(view, xpathExpr, Math.min(timeout, 10000));
+        } else {
+          await waitForSelector(view, actualSelector, Math.min(timeout, 10000));
+        }
+      } catch {
+        log.warn(`Selector "${actualSelector}" not found within timeout — attempting extraction anyway`);
+      }
+
+      const extracted = await view.evaluate(`
+        (() => {
+          const isXPath = ${JSON.stringify(isXPath)};
+          const sel = ${JSON.stringify(actualSelector)};
+          const attr = ${JSON.stringify(attribute)};
+          const all = ${JSON.stringify(all)};
+          const elements = [];
+
+          if (isXPath) {
+            const result = document.evaluate(sel, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+            for (let i = 0; i < result.snapshotLength; i++) {
+              const node = result.snapshotItem(i);
+              if (node.nodeType === Node.ELEMENT_NODE) elements.push(node);
+            }
+          } else {
+            document.querySelectorAll(sel).forEach(el => elements.push(el));
+          }
+
+          if (!all && elements.length > 0) elements.length = 1;
+
+          return elements.map(el => {
+            if (attr === "text") return (el.textContent || "").trim();
+            if (attr === "innerHTML") return el.innerHTML;
+            return el.getAttribute(attr) || "";
+          });
+        })()
+      `) as string[];
+
+      const currentUrl = view.url;
+      log.info(`Extracted ${extracted.length} element(s) from ${currentUrl}`);
+
+      return {
+        ok: true,
+        url: currentUrl,
+        selector,
+        attribute,
+        count: extracted.length,
+        data: extracted,
+      };
+    } catch (error) {
+      log.error(`Extraction failed: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to extract: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/web/browser-navigate.ts

@@ -0,0 +1,106 @@
+/**
+ * browser_navigate - Navigate to URL and get rendered content
+ *
+ * @category web
+ * @seedId browser_navigate
+ * @spanish navegar a url, abrir página, sitio web
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { getBrowserService, waitForSelector } from "./browser-service.ts";
+
+const log = logger.child("browser-navigate");
+
+export const browserNavigateTool: Tool = {
+  name: "browser_navigate",
+  description: "Navigate browser to URL, get rendered page content (supports JS). Spanish: navegar a url, abrir página, sitio web",
+  parameters: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The URL to navigate to",
+      },
+      waitFor: {
+        type: "string",
+        description: "CSS selector to wait for before returning (optional)",
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (default: 30000)",
+      },
+    },
+    required: ["url"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const url = params.url as string;
+    const waitFor = params.waitFor as string | undefined;
+    const timeout = (params.timeout as number) ?? 30000;
+
+    const browserService = getBrowserService();
+    if (!browserService?.isAvailable()) {
+      log.warn("Browser not available");
+      return {
+        ok: false,
+        error: "Browser automation not available. Install Chrome/Chromium.",
+      };
+    }
+
+    log.info(`Navigating: ${url}${waitFor ? ` (waiting for: ${waitFor})` : ""}`);
+
+    try {
+      const view = await browserService.getView();
+      if (!view) return { ok: false, error: "Browser automation not available. Install Chrome/Chromium." };
+
+      await view.navigate(url);
+
+      // Esperar a que JS termine de ejecutar
+      await Bun.sleep(500);
+
+      if (waitFor) {
+        try {
+          await waitForSelector(view, waitFor, timeout);
+        } catch {
+          log.warn(`Selector "${waitFor}" not found within timeout`);
+        }
+      }
+
+      const finalUrl = view.url;
+
+      // Extraer texto limpio del DOM
+      const content = await view.evaluate(`
+        (() => {
+          try {
+            document.querySelectorAll("script, style, noscript, meta, link, iframe").forEach(el => el.remove());
+            let text = document.body?.innerText || document.documentElement?.innerText || "";
+            text = text.replace(/\\s+/g, " ").trim();
+            return text.slice(0, 50000);
+          } catch (e) {
+            return "Error extracting content: " + e.message;
+          }
+        })()
+      `) as string;
+
+      log.info(`Navigation successful: ${finalUrl} (${content.length} chars)`);
+
+      return {
+        ok: true,
+        url,
+        finalUrl,
+        content,
+        length: content.length,
+      };
+    } catch (error) {
+      const msg = (error as Error).message;
+
+      if (msg.includes("timeout")) {
+        log.error(`Navigation timeout: ${url}`);
+        return { ok: false, error: `Timeout (${timeout}ms): la página tardó demasiado.` };
+      }
+
+      log.error(`Navigation failed: ${msg}`);
+      return { ok: false, error: `Failed to navigate: ${msg}` };
+    }
+  },
+};

package/packages/core/src/tools/web/browser-screenshot.ts

@@ -0,0 +1,87 @@
+/**
+ * browser_screenshot - Take screenshot of current browser page
+ *
+ * @category web
+ * @seedId browser_screenshot
+ * @spanish captura de pantalla, screenshot, imagen de página
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { getBrowserService, screenshotElement } from "./browser-service.ts";
+
+const log = logger.child("browser-screenshot");
+
+export const browserScreenshotTool: Tool = {
+  name: "browser_screenshot",
+  description: "Take screenshot of current browser page. Spanish: captura de pantalla, screenshot, imagen de página",
+  parameters: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "URL to navigate to before screenshot (optional)",
+      },
+      fullPage: {
+        type: "boolean",
+        description: "Capture full page height (default: false)",
+      },
+      selector: {
+        type: "string",
+        description: "CSS selector of specific element to screenshot (optional)",
+      },
+    },
+    required: [],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const url = params.url as string | undefined;
+    const fullPage = (params.fullPage as boolean) ?? false;
+    const selector = params.selector as string | undefined;
+
+    const browserService = getBrowserService();
+    if (!browserService?.isAvailable()) {
+      log.warn("Browser not available");
+      return {
+        ok: false,
+        error: "Browser automation not available. Install Chrome/Chromium.",
+      };
+    }
+
+    log.info(`Taking screenshot${url ? ` of: ${url}` : ""}${selector ? ` (element: ${selector})` : ""}`);
+
+    try {
+      const view = await browserService.getView();
+      if (!view) return { ok: false, error: "Browser automation not available. Install Chrome/Chromium." };
+
+      if (url) {
+        await view.navigate(url);
+        await Bun.sleep(500);
+      }
+
+      let screenshot: string;
+
+      if (selector) {
+        screenshot = await screenshotElement(view, selector);
+      } else {
+        screenshot = await view.screenshot({ encoding: "base64", format: "png" });
+      }
+
+      const currentUrl = view.url;
+      log.info(`Screenshot captured: ${currentUrl} (${screenshot.length} base64 chars)`);
+
+      return {
+        ok: true,
+        url: currentUrl,
+        screenshot,
+        format: "png",
+        encoding: "base64",
+        fullPage,
+        selector,
+        viewport: { width: 1280, height: 800 },
+      };
+    } catch (error) {
+      log.error(`Screenshot failed: ${(error as Error).message}`);
+      return { ok: false, error: `Failed to take screenshot: ${(error as Error).message}` };
+    }
+  },
+};

package/packages/core/src/tools/web/browser-script.ts

@@ -0,0 +1,88 @@
+/**
+ * browser_script - Execute arbitrary JavaScript in page context
+ *
+ * @category web
+ * @seedId browser_script
+ * @spanish ejecutar javascript, script, código, función, evaluar
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { getBrowserService } from "./browser-service.ts";
+
+const log = logger.child("browser-script");
+
+export const browserScriptTool: Tool = {
+  name: "browser_script",
+  description: "Execute arbitrary JavaScript in the browser page context and get the result. Spanish: ejecutar javascript, script, código, función, evaluar",
+  parameters: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "URL to navigate to before executing (optional)",
+      },
+      script: {
+        type: "string",
+        description: "JavaScript code to execute in page context",
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (default: 30000)",
+      },
+    },
+    required: ["script"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const url = params.url as string | undefined;
+    const script = params.script as string;
+    const timeout = (params.timeout as number) ?? 30000;
+
+    const browserService = getBrowserService();
+    if (!browserService?.isAvailable()) {
+      log.warn("Browser not available");
+      return {
+        ok: false,
+        error: "Browser automation not available. Install Chrome/Chromium.",
+      };
+    }
+
+    log.info(`Executing script${url ? ` on ${url}` : ""} (${script.length} chars)`);
+
+    try {
+      const view = await browserService.getView();
+      if (!view) return { ok: false, error: "Browser automation not available. Install Chrome/Chromium." };
+
+      if (url) {
+        await view.navigate(url);
+        await Bun.sleep(500);
+      }
+
+      const wrappedScript = `(async () => { try { return await (async () => { ${script} })(); } catch(e) { throw new Error('Script error: ' + e.message); } })()`;
+      const result = await view.evaluate(wrappedScript);
+
+      const currentUrl = view.url;
+      log.info(`Script executed successfully on ${currentUrl}`);
+
+      let serializedResult;
+      try {
+        serializedResult = JSON.parse(JSON.stringify(result));
+      } catch {
+        serializedResult = String(result);
+      }
+
+      return {
+        ok: true,
+        url: currentUrl,
+        result: serializedResult,
+        scriptLength: script.length,
+      };
+    } catch (error) {
+      log.error(`Script execution failed: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to execute script: ${(error as Error).message}`,
+      };
+    }
+  },
+};