@johpaz/hive-sdk 0.1.5 → 0.2.0

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

@@ -1,336 +1,40 @@
 /**
- * BrowserService — Browser automation via agent-browser CLI (Rust).
+ * BrowserService — el navegador que usan las tools de `tools/web/`.
  *
- * Flujo:
- *  1. Detecta si agent-browser está instalado (lazy install en primer uso).
- *  2. Ejecuta comandos via CLI con --json para output estructurado.
- *  3. El daemon de agent-browser maneja Chrome internamente via CDP.
- *  4. Las herramientas de browser usan AgentBrowserView (API compatible con CDPClient).
+ * Hay un solo backend: `WebViewBackend` (webview-backend.ts), que es
+ * `Bun.WebView` in-process. No se instala nada ni se descarga nada; lo único
+ * que pide es un navegador Chromium en el sistema (o `BUN_CHROME_PATH`), y con
+ * ese motor corre headless, así que sirve igual en un escritorio que en un
+ * servidor sin display.
+ *
+ * Acá vivió un segundo backend por CLI (agent-browser) mientras se creyó que el
+ * WebView necesitaba entorno gráfico. Medido en Bun 1.4 no era cierto, y lo que
+ * quedaba era el costo: ~40 ms de `Bun.spawn` por operación contra ~0,3 ms, un
+ * `bun add agent-browser@latest` ejecutado en producción al primer uso —versión
+ * flotante, bajada de npm— y ~88 MB más su propia copia de Chrome. Se retiró.
+ *
+ * El servicio es un singleton con una sola vista: `getView()` la abre al primer
+ * uso y la reutiliza, para que `browser_navigate` establezca el contexto sobre
+ * el que operan las tools siguientes.
  */
 
 import { logger } from "../../utils/logger.ts";
 import type { Config } from "../../config/loader.ts";
-import { existsSync, mkdirSync, readFileSync, rmSync } from "fs";
-import { homedir, tmpdir } from "os";
-import { dirname, join, resolve } from "path";
+import { resolveBackendKind, type BrowserBackend, type BrowserBackendKind } from "./browser-backend.ts";
 
 const log = logger.child("browser-service");
 
-// ─── Instalación lazy de agent-browser ────────────────────────────────────────
-
-const HIVE_DIR = join(homedir(), ".hive");
-const AGENT_BROWSER_DIR = join(HIVE_DIR, "agent-browser");
-const AGENT_BROWSER_PKG_JSON = join(AGENT_BROWSER_DIR, "package.json");
-const DEFAULT_SESSION_NAME = "hive";
-
-/** Check if agent-browser is installed in the cache dir by running --version */
-async function isAgentBrowserInstalled(): Promise<boolean> {
-  if (!existsSync(AGENT_BROWSER_PKG_JSON)) return false;
-  try {
-    const proc = Bun.spawn(["bun", "run", "agent-browser", "--version"], {
-      cwd: AGENT_BROWSER_DIR,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const exitCode = await proc.exited;
-    return exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-
-async function installAgentBrowser(): Promise<void> {
-  mkdirSync(AGENT_BROWSER_DIR, { recursive: true });
-
-  // Create minimal package.json
-  const pkg = { name: "hive-agent-browser", version: "1.0.0", dependencies: {} };
-  await Bun.write(AGENT_BROWSER_PKG_JSON, JSON.stringify(pkg, null, 2));
-
-  log.info("📦 Instalando agent-browser (primera vez, ~75MB)...");
-  const proc = Bun.spawn(["bun", "add", "agent-browser@latest"], {
-    cwd: AGENT_BROWSER_DIR,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const exitCode = await proc.exited;
-  const stderr = await new Response(proc.stderr).text();
-
-  if (exitCode !== 0) {
-    throw new Error(`bun add agent-browser failed: ${stderr}`);
-  }
-
-  log.info("✅ agent-browser instalado.");
-}
-
-/** Run agent-browser CLI from the cache directory — cross-platform via bun run */
-async function runAgentBrowser(
-  args: string[]
-): Promise<{ success: boolean; data?: any; error?: string }> {
-  const proc = Bun.spawn(["bun", "run", "agent-browser", ...args], {
-    cwd: AGENT_BROWSER_DIR,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-  const exitCode = await proc.exited;
-
-  if (exitCode !== 0 && !stdout.trim()) {
-    throw new Error(stderr || `agent-browser ${args[0]} failed`);
-  }
-
-  try {
-    const result = JSON.parse(stdout.trim().split("\n").pop() || "{}");
-    return result;
-  } catch {
-    return { success: true, data: { raw: stdout.trim() } };
-  }
-}
-
-async function ensureChromeInstalled(): Promise<void> {
-  log.info("🔍 Verificando Chrome para agent-browser...");
-  const res = await runAgentBrowser(["open", "about:blank", "--session", DEFAULT_SESSION_NAME, "--json"]);
-
-  if (!res.success) {
-    const err = res.error || "";
-    // Chrome not installed — trigger install
-    if (err.includes("not found") || err.includes("install")) {
-      log.info("📥 Descargando Chrome (agent-browser install)...");
-      const installProc = Bun.spawn(["bun", "run", "agent-browser", "install"], {
-        cwd: AGENT_BROWSER_DIR,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-      const installExit = await installProc.exited;
-      if (installExit !== 0) {
-        const installErr = await new Response(installProc.stderr).text();
-        throw new Error(`agent-browser install failed: ${installErr}`);
-      }
-      log.info("✅ Chrome descargado.");
-      return;
-    }
-    throw new Error(`agent-browser chrome check failed: ${err}`);
-  }
-}
-
-// ─── AgentBrowserView (API compatible con CDPClient) ──────────────────────────
-
-export class AgentBrowserView {
-  private sessionName: string;
-  private _url = "";
-
-  get url(): string { return this._url; }
-  get title(): string { return ""; }
-  get loading(): boolean { return false; }
-  get isConnected(): boolean { return true; }
-
-  constructor(sessionName: string = DEFAULT_SESSION_NAME) {
-    this.sessionName = sessionName;
-  }
-
-  protected async run(args: string[]): Promise<{ success: boolean; data?: any; error?: string }> {
-    return runAgentBrowser(["--session", this.sessionName, "--json", ...args]);
-  }
-
-  async navigate(url: string): Promise<void> {
-    // Ensure protocol
-    const target = /^https?:\/\//.test(url) ? url : `https://${url}`;
-    const res = await this.run(["open", target]);
-    if (!res.success) throw new Error(res.error || "navigate failed");
-    this._url = res.data?.url || target;
-    // Small delay to let JS settle (same as old implementation)
-    await new Promise(r => setTimeout(r, 500));
-  }
-
-  async evaluate<T = unknown>(script: string): Promise<T> {
-    let wrapped = script;
-    const trimmed = script.trim();
-
-    // If script contains top-level await, wrap in async IIFE to make it valid JS
-    if (/\bawait\b/.test(script) && !trimmed.startsWith("(async") && !trimmed.startsWith("async function")) {
-      if (trimmed.startsWith("return")) {
-        wrapped = `(async () => { ${script} })()`;
-      } else {
-        wrapped = `(async () => { return ${script}; })()`;
-      }
-    }
-
-    const res = await this.run(["eval", wrapped]);
-    if (!res.success) throw new Error(res.error || "eval failed");
-    return res.data?.result as T;
-  }
-
-  async screenshot(options?: {
-    encoding?: "blob" | "buffer" | "base64" | "shmem";
-    format?: "png" | "jpeg" | "webp";
-    quality?: number;
-    clip?: { x: number; y: number; width: number; height: number; scale: number };
-  }): Promise<string> {
-    // Build args
-    const args: string[] = ["screenshot"];
-
-    if (options?.format === "jpeg") {
-      args.push("--screenshot-format", "jpeg");
-    }
-    if (options?.quality) {
-      args.push("--screenshot-quality", String(options.quality));
-    }
-
-    // If clip/selector is provided, agent-browser screenshot accepts a positional selector
-    // For element screenshots, we can pass a selector as first positional arg
-    // But we don't have selector in options here — the old CDPClient didn't use it either
-    // screenshotElement helper handles element-specific screenshots
-
-    const res = await this.run(args);
-    if (!res.success) throw new Error(res.error || "screenshot failed");
-
-    const path = res.data?.path as string;
-    if (!path) throw new Error("screenshot did not return a path");
-
-    const data = readFileSync(path);
-    const base64 = Buffer.from(data).toString("base64");
-
-    // Cleanup temp file
-    try { rmSync(path); } catch { /* ignore */ }
-
-    return base64;
-  }
-
-  async click(selector: string, _options?: Record<string, unknown>): Promise<void> {
-    const res = await this.run(["click", selector]);
-    if (!res.success) throw new Error(res.error || `click failed: ${selector}`);
-  }
-
-  async type(text: string): Promise<void> {
-    // Fallback: keyboard inserttext (requires focused element)
-    const res = await this.run(["keyboard", "inserttext", text]);
-    if (!res.success) throw new Error(res.error || "type failed");
-  }
-
-  async typeIn(selector: string, text: string): Promise<void> {
-    const res = await this.run(["type", selector, text]);
-    if (!res.success) throw new Error(res.error || `type failed: ${selector}`);
-  }
-
-  async fill(selector: string, text: string): Promise<void> {
-    const res = await this.run(["fill", selector, text]);
-    if (!res.success) throw new Error(res.error || `fill failed: ${selector}`);
-  }
-
-  async press(key: string, options?: { modifiers?: string[] }): Promise<void> {
-    const modifiers = options?.modifiers ?? [];
-    const combo = modifiers.length > 0
-      ? `${modifiers.join("+")}+${key}`
-      : key;
-    const res = await this.run(["press", combo]);
-    if (!res.success) throw new Error(res.error || `press failed: ${combo}`);
-  }
-
-  async scroll(dx: number, dy: number): Promise<void> {
-    const dir = dy > 0 ? "down" : dy < 0 ? "up" : dx > 0 ? "right" : "left";
-    const px = Math.abs(dy || dx);
-    const res = await this.run(["scroll", dir, String(px)]);
-    if (!res.success) throw new Error(res.error || "scroll failed");
-  }
-
-  async scrollTo(selector: string, _options?: { behavior?: "smooth" | "instant" }): Promise<void> {
-    // agent-browser has scrollintoview (behavior not supported via CLI)
-    const res = await this.run(["scrollintoview", selector]);
-    if (!res.success) throw new Error(res.error || `scrollTo failed: ${selector}`);
-  }
-
-  async back(): Promise<void> {
-    const res = await this.run(["back"]);
-    if (!res.success) throw new Error(res.error || "back failed");
-    await new Promise<void>(r => setTimeout(r, 800));
-  }
-
-  async forward(): Promise<void> {
-    const res = await this.run(["forward"]);
-    if (!res.success) throw new Error(res.error || "forward failed");
-    await new Promise<void>(r => setTimeout(r, 800));
-  }
-
-  async reload(): Promise<void> {
-    const res = await this.run(["reload"]);
-    if (!res.success) throw new Error(res.error || "reload failed");
-    await new Promise<void>(r => setTimeout(r, 1000));
-  }
-
-  async resize(width: number, height: number): Promise<void> {
-    const res = await this.run(["set", "viewport", String(width), String(height)]);
-    if (!res.success) throw new Error(res.error || "resize failed");
-  }
-
-  /** Capture accessibility tree snapshot (compact, AI-optimized). ~200-600 chars vs ~3000+ innerText. */
-  async snapshot(options?: { compact?: boolean; depth?: number; interactiveOnly?: boolean }): Promise<string> {
-    const args = ["snapshot"];
-    if (options?.compact !== false) args.push("-c");
-    if (options?.depth) args.push("-d", String(options.depth));
-    if (options?.interactiveOnly) args.push("-i");
-
-    const res = await this.run(args);
-    if (!res.success) throw new Error(res.error || "snapshot failed");
-    return res.data?.snapshot as string || "";
-  }
-
-  async cdp<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T> {
-    const script = `
-      (() => {
-        // agent-browser does not expose raw CDP directly via CLI for all methods.
-        // For common methods we can emulate; for others we return a notice.
-        const method = ${JSON.stringify(method)};
-        const params = ${JSON.stringify(params ?? {})};
-        return { method, params, note: "CDP passthrough not fully supported by agent-browser CLI" };
-      })()
-    `;
-    const res = await this.run(["eval", script]);
-    if (!res.success) throw new Error(res.error || `cdp failed: ${method}`);
-    return res.data?.result as T;
-  }
-
-  close(): void {
-    // Close the session
-    this.run(["close"]).catch(() => { /* ignore */ });
-  }
-}
-
-// ─── Backwards compatibility exports ──────────────────────────────────────────
-
-/** @deprecated Use AgentBrowserView instead */
-export class CDPClient extends AgentBrowserView {
-  private _launched = false;
-
-  async launch(_spec?: unknown, _options?: unknown): Promise<void> {
-    if (this._launched) return;
-    // Verify agent-browser is working by opening about:blank
-    const res = await this.run(["open", "about:blank"]);
-    if (!res.success) throw new Error(res.error || "Failed to launch agent-browser");
-    this._launched = true;
-  }
-
-  static closeAll(): void {
-    // agent-browser sessions are managed by the daemon; no explicit cleanup needed
-  }
-}
-
-/** @deprecated No longer used — agent-browser handles browser detection internally */
-export function detectBrowser(_options?: unknown): undefined {
-  return undefined;
-}
-
-/** @deprecated No longer used */
-export type LaunchSpec = { kind: "remote"; cdpUrl: string };
+/** Alias histórico: las tools sólo dependen del contrato, no de la implementación. */
+export type BrowserView = BrowserBackend;
 
-// ─── BrowserService (singleton) ───────────────────────────────────────────────
+/** Re-export para que quien importe el servicio no tenga que conocer el módulo del contrato. */
+export type { BrowserBackend, BrowserBackendKind } from "./browser-backend.ts";
+export { isWebViewSupported, resolveBackendKind, findChrome } from "./browser-backend.ts";
 
-export type BrowserView = AgentBrowserView;
-
-let _client: AgentBrowserView | null = null;
+let _client: BrowserBackend | null = null;
 let _available = false;
 let _launching = false;
+let _kind: BrowserBackendKind = "webview";
 
 export class BrowserService {
   private static instance: BrowserService | null = null;
@@ -348,7 +52,10 @@ export class BrowserService {
   }
 
   /**
-   * Probe / lazy install agent-browser.
+   * Deja el servicio listo. No abre el navegador: eso pasa en el primer uso.
+   *
+   * Si el entorno no tiene motor, `ensureView()` falla ahí con un mensaje que
+   * dice qué instalar, y las tools reportan el navegador como no disponible.
    */
   async start(): Promise<boolean> {
     const b = this.config.tools?.browser;
@@ -357,29 +64,9 @@ export class BrowserService {
       return false;
     }
 
-    const installed = await isAgentBrowserInstalled();
-
-    if (!installed) {
-      try {
-        await installAgentBrowser();
-      } catch (err) {
-        log.warn(`No se pudo instalar agent-browser: ${(err as Error).message}`);
-        log.warn("  Instalar manualmente: bun add -g agent-browser");
-        _available = false;
-        return false;
-      }
-    }
-
-    try {
-      await ensureChromeInstalled();
-    } catch (err) {
-      log.warn(`Chrome no pudo prepararse: ${(err as Error).message}`);
-      _available = false;
-      return false;
-    }
-
+    _kind = resolveBackendKind(b?.backend);
     _available = true;
-    log.info("✅ agent-browser listo — se abrirá al primer uso");
+    log.info("✅ Navegador: Bun.WebView (in-process, headless)");
     return true;
   }
 
@@ -392,9 +79,15 @@ export class BrowserService {
     }
     _launching = true;
     try {
-      const sessionName = this.config.tools?.browser?.sessionName ?? DEFAULT_SESSION_NAME;
-      _client = new AgentBrowserView(sessionName);
-      log.info("✅ Browser abierto — el usuario verá las acciones del agente");
+      const { WebViewBackend } = await import("./webview-backend.ts");
+      // Headless salvo que se pida lo contrario con `tools.browser.headless: false`.
+      const visible = this.config.tools?.browser?.headless === false;
+      _client = new WebViewBackend({
+        show: visible,
+        persistSession: this.config.tools?.browser?.persistSession,
+      });
+
+      log.info(`✅ Browser abierto (${visible ? "con ventana" : "headless"})`);
       return true;
     } catch (err) {
       log.warn(`Browser no pudo iniciarse: ${(err as Error).message}`);
@@ -406,20 +99,25 @@ export class BrowserService {
     }
   }
 
-  async getView(): Promise<AgentBrowserView | null> {
+  async getView(): Promise<BrowserBackend | null> {
     if (!_available) return null;
     await this._ensureLaunched();
     return _client;
   }
 
-  getViewSync(): AgentBrowserView | null {
+  getViewSync(): BrowserBackend | null {
     return _client;
   }
 
-  async getPage(): Promise<AgentBrowserView | null> {
+  async getPage(): Promise<BrowserBackend | null> {
     return this.getView();
   }
 
+  /** Qué backend quedó activo — lo reporta `hive doctor` y los tests. */
+  getBackendKind(): BrowserBackendKind {
+    return _kind;
+  }
+
   isAvailable(): boolean {
     return _available;
   }
@@ -428,12 +126,20 @@ export class BrowserService {
     return _available && _client !== null;
   }
 
-  getInfo(): { running: boolean } {
-    return { running: this.isRunning() };
+  getInfo(): { running: boolean; backend: BrowserBackendKind } {
+    return { running: this.isRunning(), backend: _kind };
   }
 
   async stop(): Promise<void> {
     if (_client) {
+      // El volcado de cookies está debounceado: si se cierra antes de que
+      // dispare, el login de esta sesión se pierde. Por eso se fuerza acá.
+      const flushable = _client as BrowserBackend & { flushSession?: () => Promise<void> };
+      if (typeof flushable.flushSession === "function") {
+        await flushable.flushSession().catch((err: Error) => {
+          log.warn(`no se pudo guardar la sesión al cerrar: ${err.message}`);
+        });
+      }
       _client.close();
       _client = null;
       log.info("✅ Browser cerrado");
@@ -459,10 +165,32 @@ export function getBrowserService(): BrowserService | null {
   return browserServiceInstance;
 }
 
+/**
+ * Cierra todo lo que este proceso haya abierto, pase lo que pase.
+ *
+ * `stop()` es el camino ordenado —vuelca la sesión antes de cerrar— y esto es
+ * la red debajo: `Bun.WebView.closeAll()` mata cualquier vista que haya quedado
+ * viva, incluida alguna abierta fuera del servicio. El apagado del gateway
+ * llama a esto; antes llamaba a un `CDPClient.closeAll()` que no hacía nada, y
+ * por eso Chrome sobrevivía al gateway y la sesión no se guardaba nunca.
+ */
+export async function shutdownBrowser(): Promise<void> {
+  try {
+    await browserServiceInstance?.stop();
+  } catch (err) {
+    log.warn(`cierre del navegador incompleto: ${(err as Error).message}`);
+  }
+  try {
+    (globalThis as { Bun?: { WebView?: { closeAll?: () => void } } }).Bun?.WebView?.closeAll?.();
+  } catch {
+    /* no hay vistas que cerrar */
+  }
+}
+
 // ─── Helpers (misma API que antes) ───────────────────────────────────────────
 
 export async function waitForSelector(
-  view: AgentBrowserView,
+  view: BrowserBackend,
   selector: string,
   timeout = 30000
 ): Promise<void> {
@@ -476,7 +204,7 @@ export async function waitForSelector(
 }
 
 export async function waitForCondition(
-  view: AgentBrowserView,
+  view: BrowserBackend,
   expression: string,
   timeout = 30000
 ): Promise<void> {
@@ -490,19 +218,10 @@ export async function waitForCondition(
 }
 
 export async function screenshotElement(
-  view: AgentBrowserView,
+  view: BrowserBackend,
   selector: string
 ): Promise<string> {
-  const res = await (view as any).run(["screenshot", selector]);
-  if (!res.success) throw new Error(res.error || `screenshot failed: ${selector}`);
-
-  const path = res.data?.path as string;
-  if (!path) throw new Error("screenshot did not return a path");
-
-  const data = readFileSync(path);
-  const base64 = Buffer.from(data).toString("base64");
-
-  try { rmSync(path); } catch { /* ignore */ }
-
-  return base64;
+  // El recorte es responsabilidad del backend: sabe si puede pedirlo por CDP o
+  // si tiene que resolverlo sobre el viewport.
+  return view.screenshotElement(selector);
 }

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

@@ -0,0 +1,125 @@
+/**
+ * Persistencia de la sesión del navegador — cookies entre reinicios.
+ *
+ * `Bun.WebView` abre Chrome con un perfil efímero: `/tmp/.<hash>.bun-chrome`,
+ * donde el hash cambia de un proceso a otro y no hay forma de fijarlo (probado:
+ * el constructor ignora `userDataDir` y `args`). Sin esto, cada reinicio del
+ * gateway perdería todos los logins que el agente haya hecho.
+ *
+ * La solución es guardar las cookies por CDP y volver a ponerlas al arrancar.
+ * Van al almacén de secretos —keychain del sistema, o la colección cifrada— y
+ * no a un JSON en claro: una cookie de sesión vale tanto como la contraseña.
+ */
+
+import { logger } from "../../utils/logger.ts";
+import { loadSecret, storeSecret, deleteSecret } from "../../storage/crypto.ts";
+
+const log = logger.child("browser-session");
+
+const SECRET_NAME = "browser.session.cookies";
+
+/**
+ * Tope de lo que se guarda. El almacén de secretos no está pensado para
+ * megabytes, y un navegador que estuvo horas de paseo junta cookies de
+ * publicidad que no le sirven a nadie.
+ */
+const MAX_BYTES = 256 * 1024;
+
+/** Los campos que `Network.setCookies` acepta de vuelta. */
+export interface StoredCookie {
+  name: string;
+  value: string;
+  domain: string;
+  path?: string;
+  expires?: number;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: string;
+}
+
+/**
+ * ¿Se guarda la sesión? Default sí; `HIVE_BROWSER_PERSIST_SESSION=0` o
+ * `tools.browser.persistSession: false` la apagan (kioscos, equipos
+ * compartidos, o cuando se quiere que cada tarea arranque sin historia).
+ */
+export function sessionPersistenceEnabled(configured?: boolean): boolean {
+  const env = process.env.HIVE_BROWSER_PERSIST_SESSION;
+  if (env !== undefined) return env !== "0" && env.toLowerCase() !== "false";
+  return configured !== false;
+}
+
+/** Deja sólo los campos reutilizables y descarta lo ya vencido. */
+export function normalizeCookies(raw: unknown): StoredCookie[] {
+  if (!Array.isArray(raw)) return [];
+  const ahora = Date.now() / 1000;
+  const out: StoredCookie[] = [];
+
+  for (const item of raw) {
+    // Lo que llega es JSON crudo: del protocolo, o de un archivo que alguien
+    // editó. Un null en la lista no puede tumbar la restauración entera.
+    if (typeof item !== "object" || item === null) continue;
+    const c = item as Record<string, unknown>;
+    const name = typeof c.name === "string" ? c.name : null;
+    const value = typeof c.value === "string" ? c.value : null;
+    const domain = typeof c.domain === "string" ? c.domain : null;
+    if (!name || value === null || !domain) continue;
+
+    // -1 es la marca de CDP para "cookie de sesión": esas se conservan, que son
+    // justamente las del login. Las que traen fecha y ya pasó, no.
+    const expires = typeof c.expires === "number" ? c.expires : undefined;
+    if (expires !== undefined && expires > 0 && expires < ahora) continue;
+
+    out.push({
+      name,
+      value,
+      domain,
+      path: typeof c.path === "string" ? c.path : undefined,
+      expires: expires !== undefined && expires > 0 ? expires : undefined,
+      httpOnly: c.httpOnly === true,
+      secure: c.secure === true,
+      sameSite: typeof c.sameSite === "string" ? c.sameSite : undefined,
+    });
+  }
+  return out;
+}
+
+export async function loadStoredCookies(): Promise<StoredCookie[]> {
+  try {
+    const raw = await loadSecret(SECRET_NAME);
+    if (!raw) return [];
+    return normalizeCookies(JSON.parse(raw));
+  } catch (err) {
+    log.warn(`no se pudo leer la sesión guardada: ${(err as Error).message}`);
+    return [];
+  }
+}
+
+export async function storeCookies(cookies: unknown[]): Promise<number> {
+  const limpias = normalizeCookies(cookies);
+  if (!limpias.length) return 0;
+
+  // Si no entra, se recorta por el final: las de sesión y las de dominio propio
+  // suelen venir primero, y perder una cookie de tracking no le duele a nadie.
+  let payload = JSON.stringify(limpias);
+  let guardadas = limpias;
+  while (payload.length > MAX_BYTES && guardadas.length > 1) {
+    guardadas = guardadas.slice(0, Math.floor(guardadas.length / 2));
+    payload = JSON.stringify(guardadas);
+  }
+
+  try {
+    await storeSecret(SECRET_NAME, payload);
+    return guardadas.length;
+  } catch (err) {
+    log.warn(`no se pudo guardar la sesión: ${(err as Error).message}`);
+    return 0;
+  }
+}
+
+export async function clearStoredSession(): Promise<void> {
+  try {
+    await deleteSecret(SECRET_NAME);
+  } catch (err) {
+    log.warn(`no se pudo borrar la sesión: ${(err as Error).message}`);
+  }
+}

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

@@ -53,7 +53,7 @@ export const browserTypeTool: Tool = {
       log.warn("Browser not available");
       return {
         ok: false,
-        error: "Browser automation not available. Install agent-browser.",
+        error: "Browser automation not available. Install Chrome or Chromium (or run `hive doctor`).",
       };
     }
 
@@ -61,7 +61,7 @@ export const browserTypeTool: Tool = {
 
     try {
       const view = await browserService.getView();
-      if (!view) return { ok: false, error: "Browser automation not available. Install agent-browser." };
+      if (!view) return { ok: false, error: "Browser automation not available. Install Chrome or Chromium (or run `hive doctor`)." };
 
       if (url) {
         await view.navigate(url);