hyper-agent-browser 0.1.0

package/src/commands/info.ts

@@ -0,0 +1,195 @@
+import type { Page } from "patchright";
+import { AccessibilityExtractor } from "../snapshot/accessibility";
+import { DomSnapshotExtractor } from "../snapshot/dom-extractor";
+import { SnapshotFormatter } from "../snapshot/formatter";
+
+export interface SnapshotOptions {
+  interactive?: boolean;
+  full?: boolean;
+  raw?: boolean;
+  maxElements?: number;
+  referenceStore?: any; // Will be ReferenceStore instance
+}
+
+export async function snapshot(page: Page, options: SnapshotOptions = {}): Promise<string> {
+  const interactiveOnly = options.interactive ?? true;
+
+  // Try accessibility API first, fallback to DOM extraction
+  let snapshot;
+  let domExtractor: DomSnapshotExtractor | null = null;
+
+  try {
+    const accessibilityExtractor = new AccessibilityExtractor();
+    snapshot = await accessibilityExtractor.extract(page, interactiveOnly);
+
+    // If snapshot is empty, try DOM extraction
+    if (snapshot.elements.length === 0) {
+      throw new Error("Accessibility API returned no elements");
+    }
+  } catch (error) {
+    // Fallback to DOM extraction
+    domExtractor = new DomSnapshotExtractor();
+    const elements = await domExtractor.extract(page, interactiveOnly);
+
+    snapshot = {
+      url: await page.url(),
+      title: await page.title(),
+      timestamp: Date.now(),
+      elements,
+    };
+
+    // Store element-to-selector mappings if referenceStore is provided
+    if (options.referenceStore && domExtractor) {
+      const mappings = domExtractor.getAllMappings();
+      options.referenceStore.setAll(mappings);
+      await options.referenceStore.save();
+    }
+  }
+
+  if (options.raw) {
+    const formatter = new SnapshotFormatter();
+    return formatter.formatJson(snapshot, true);
+  }
+
+  const formatter = new SnapshotFormatter();
+  return formatter.format(snapshot, {
+    maxElements: options.maxElements,
+    includeDisabled: options.full,
+  });
+}
+
+export interface ScreenshotOptions {
+  output?: string;
+  fullPage?: boolean;
+  selector?: string;
+  quality?: number;
+}
+
+export async function screenshot(page: Page, options: ScreenshotOptions = {}): Promise<string> {
+  const output = options.output || "screenshot.png";
+
+  if (options.selector) {
+    const { parseSelector } = await import("../utils/selector");
+    const parsed = parseSelector(options.selector);
+
+    let locator;
+    if (parsed.type === "css") {
+      locator = page.locator(parsed.value);
+    } else if (parsed.type === "text") {
+      locator = page.getByText(parsed.value);
+    } else if (parsed.type === "xpath") {
+      locator = page.locator(`xpath=${parsed.value}`);
+    } else {
+      throw new Error(`Unsupported selector type for screenshot: ${parsed.type}`);
+    }
+
+    await locator.screenshot({ path: output });
+  } else {
+    await page.screenshot({
+      path: output,
+      fullPage: options.fullPage,
+    });
+  }
+
+  return output;
+}
+
+// Whitelist of safe operations
+const SAFE_OPERATIONS = [
+  /^document\.title$/,
+  /^document\.URL$/,
+  /^window\.location\.href$/,
+  /^window\.innerWidth$/,
+  /^window\.innerHeight$/,
+  /^document\.body\.scrollHeight$/,
+  /^document\.body\.scrollWidth$/,
+  /^document\.readyState$/,
+];
+
+// Enhanced blacklist for dangerous patterns
+const FORBIDDEN_PATTERNS = [
+  /\b(eval|Function|constructor)\b/i,
+  /require\s*\(/,
+  /import\s*\(/,
+  /process\./,
+  /child_process/,
+  /fs\./,
+  /__dirname/,
+  /__filename/,
+  /globalThis/,
+  /window\s*\[/,
+  /\[(['"`])[a-z_]+\1\]/i, // Bracket notation: window['process']
+  /Object\.(assign|defineProperty|create)/,
+  /\.constructor/,
+  /prototype/,
+];
+
+export async function evaluate(page: Page, script: string): Promise<any> {
+  const trimmedScript = script.trim();
+
+  // 1. Whitelist mode - only allow safe operations
+  const isSafe = SAFE_OPERATIONS.some((pattern) => pattern.test(trimmedScript));
+
+  if (!isSafe) {
+    // 2. Enhanced blacklist check
+    for (const pattern of FORBIDDEN_PATTERNS) {
+      if (pattern.test(trimmedScript)) {
+        throw new Error(`Unsafe operation blocked: ${pattern.source}`);
+      }
+    }
+  }
+
+  // 3. Execute and limit result size (防止数据窃取)
+  const result = await page.evaluate(trimmedScript);
+  const serialized = JSON.stringify(result);
+
+  if (serialized.length > 100000) {
+    throw new Error("Result too large (max 100KB). Use snapshot command instead.");
+  }
+
+  return result;
+}
+
+export async function url(page: Page): Promise<string> {
+  return page.url();
+}
+
+export async function title(page: Page): Promise<string> {
+  return page.title();
+}
+
+export interface ContentOptions {
+  selector?: string;
+  maxLength?: number;
+}
+
+export async function content(page: Page, options: ContentOptions = {}): Promise<string> {
+  const maxLength = options.maxLength || 10000;
+
+  let text: string;
+  if (options.selector) {
+    const { parseSelector } = await import("../utils/selector");
+    const parsed = parseSelector(options.selector);
+
+    let locator;
+    if (parsed.type === "css") {
+      locator = page.locator(parsed.value);
+    } else if (parsed.type === "text") {
+      locator = page.getByText(parsed.value);
+    } else if (parsed.type === "xpath") {
+      locator = page.locator(`xpath=${parsed.value}`);
+    } else {
+      throw new Error(`Unsupported selector type: ${parsed.type}`);
+    }
+
+    text = (await locator.textContent()) || "";
+  } else {
+    text = (await page.textContent("body")) || "";
+  }
+
+  if (text.length > maxLength) {
+    text = `${text.slice(0, maxLength)}... (truncated at ${maxLength} chars)`;
+  }
+
+  return text;
+}

package/src/commands/navigation.ts

@@ -0,0 +1,50 @@
+import type { Page } from "patchright";
+
+export interface NavigationOptions {
+  waitUntil?: "load" | "domcontentloaded" | "networkidle";
+  timeout?: number;
+}
+
+export async function open(
+  page: Page,
+  url: string,
+  options: NavigationOptions = {},
+): Promise<void> {
+  const waitUntil = options.waitUntil || "load";
+  const timeout = options.timeout || 30000;
+
+  await page.goto(url, {
+    waitUntil,
+    timeout,
+  });
+}
+
+export async function reload(page: Page, options: NavigationOptions = {}): Promise<void> {
+  const waitUntil = options.waitUntil || "load";
+  const timeout = options.timeout || 30000;
+
+  await page.reload({
+    waitUntil,
+    timeout,
+  });
+}
+
+export async function back(page: Page, options: NavigationOptions = {}): Promise<void> {
+  const waitUntil = options.waitUntil || "load";
+  const timeout = options.timeout || 30000;
+
+  await page.goBack({
+    waitUntil,
+    timeout,
+  });
+}
+
+export async function forward(page: Page, options: NavigationOptions = {}): Promise<void> {
+  const waitUntil = options.waitUntil || "load";
+  const timeout = options.timeout || 30000;
+
+  await page.goForward({
+    waitUntil,
+    timeout,
+  });
+}

package/src/commands/session.ts

@@ -0,0 +1,83 @@
+import type { SessionManager } from "../session/manager";
+
+export interface SessionListOptions {
+  json?: boolean;
+}
+
+export async function listSessions(
+  sessionManager: SessionManager,
+  options: SessionListOptions = {},
+): Promise<string> {
+  const sessions = await sessionManager.list();
+
+  if (options.json) {
+    return JSON.stringify(sessions, null, 2);
+  }
+
+  if (sessions.length === 0) {
+    return "No sessions found.";
+  }
+
+  const lines: string[] = [];
+  lines.push(
+    `${
+      "SESSION".padEnd(15) + "STATUS".padEnd(10) + "BROWSER".padEnd(12) + "URL".padEnd(40)
+    }LAST ACTIVE`,
+  );
+  lines.push("-".repeat(100));
+
+  for (const session of sessions) {
+    const name = session.name.padEnd(15);
+    const status = session.status.padEnd(10);
+    const browser = (session.channel || "-").padEnd(12);
+    const url = (session.url || "-").slice(0, 38).padEnd(40);
+    const lastActive = formatLastActive(session.lastActiveAt);
+
+    lines.push(`${name}${status}${browser}${url}${lastActive}`);
+  }
+
+  return lines.join("\n");
+}
+
+function formatLastActive(timestamp: number): string {
+  const now = Date.now();
+  const diff = now - timestamp;
+
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+
+  if (minutes < 1) {
+    return "just now";
+  }
+  if (minutes < 60) {
+    return `${minutes} min ago`;
+  }
+  if (hours < 24) {
+    return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+  }
+  return `${days} day${days > 1 ? "s" : ""} ago`;
+}
+
+export async function closeSession(
+  sessionManager: SessionManager,
+  sessionName?: string,
+  closeAll = false,
+): Promise<string> {
+  if (closeAll) {
+    await sessionManager.closeAll();
+    return "All sessions closed.";
+  }
+
+  if (!sessionName) {
+    throw new Error("Session name required");
+  }
+
+  const session = await sessionManager.get(sessionName);
+  if (!session) {
+    throw new Error(`Session not found: ${sessionName}`);
+  }
+
+  await sessionManager.close(sessionName);
+  return `Session closed: ${sessionName}`;
+}

package/src/daemon/browser-pool.ts

@@ -0,0 +1,65 @@
+import { BrowserManager } from "../browser/manager";
+import type { BrowserManagerOptions } from "../browser/manager";
+import type { Session } from "../session/store";
+
+/**
+ * BrowserPool 管理多个 Session 的浏览器实例
+ */
+export class BrowserPool {
+  private browsers: Map<string, BrowserManager> = new Map();
+
+  async get(session: Session, options: BrowserManagerOptions = {}): Promise<BrowserManager> {
+    const key = session.name;
+
+    if (this.browsers.has(key)) {
+      const browser = this.browsers.get(key)!;
+
+      // 检查浏览器是否还连接
+      if (browser.isConnected()) {
+        return browser;
+      }
+
+      // 浏览器断开连接，尝试重连
+      try {
+        await browser.connect();
+        return browser;
+      } catch (error) {
+        console.error(`Failed to reconnect browser for session ${key}:`, error);
+        // 重连失败，移除旧实例
+        this.browsers.delete(key);
+      }
+    }
+
+    // 创建新的浏览器实例
+    const browser = new BrowserManager(session, options);
+    await browser.connect();
+    this.browsers.set(key, browser);
+
+    return browser;
+  }
+
+  async close(sessionName: string): Promise<boolean> {
+    const browser = this.browsers.get(sessionName);
+    if (!browser) {
+      return false;
+    }
+
+    await browser.close();
+    this.browsers.delete(sessionName);
+    return true;
+  }
+
+  async closeAll(): Promise<void> {
+    const closePromises = Array.from(this.browsers.values()).map((b) => b.close());
+    await Promise.all(closePromises);
+    this.browsers.clear();
+  }
+
+  getActiveSessions(): string[] {
+    return Array.from(this.browsers.keys());
+  }
+
+  size(): number {
+    return this.browsers.size;
+  }
+}

package/src/daemon/client.ts

@@ -0,0 +1,128 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { CommandRequest, CommandResponse } from "./server";
+
+const CONFIG_FILE = join(homedir(), ".hab", "daemon.json");
+
+export class DaemonClient {
+  private host = "127.0.0.1";
+  private port = 9527;
+
+  async ensureDaemonRunning(): Promise<void> {
+    // Load daemon config
+    if (existsSync(CONFIG_FILE)) {
+      try {
+        const content = await readFile(CONFIG_FILE, "utf-8");
+        const config = JSON.parse(content);
+        this.host = config.host;
+        this.port = config.port;
+      } catch {
+        // Use defaults
+      }
+    }
+
+    // Check if daemon is running
+    const healthy = await this.checkHealth();
+    if (healthy) {
+      return;
+    }
+
+    // Auto-start daemon
+    console.log("Starting daemon...");
+    await this.startDaemon();
+
+    // Wait for daemon to be ready
+    for (let i = 0; i < 30; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      if (await this.checkHealth()) {
+        console.log("Daemon started successfully");
+        return;
+      }
+    }
+
+    throw new Error("Failed to start daemon");
+  }
+
+  private async checkHealth(): Promise<boolean> {
+    try {
+      const response = await fetch(`http://${this.host}:${this.port}/health`, {
+        signal: AbortSignal.timeout(1000),
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  private async startDaemon(): Promise<void> {
+    // Start daemon in background
+    const projectRoot = join(import.meta.dir, "../..");
+    const daemonScript = join(projectRoot, "src/daemon/main.ts");
+
+    const proc = Bun.spawn({
+      cmd: ["bun", daemonScript, "start"],
+      cwd: projectRoot,
+      stdout: "ignore",
+      stderr: "ignore",
+      stdin: "ignore",
+    });
+
+    proc.unref();
+  }
+
+  async execute(request: CommandRequest): Promise<CommandResponse> {
+    await this.ensureDaemonRunning();
+
+    try {
+      const response = await fetch(`http://${this.host}:${this.port}/execute`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(request),
+        signal: AbortSignal.timeout(60000), // 60s timeout
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Daemon error: ${error}`);
+      }
+
+      return await response.json();
+    } catch (error) {
+      if (error instanceof Error && error.name === "TimeoutError") {
+        throw new Error("Command timed out");
+      }
+      throw error;
+    }
+  }
+
+  async closeSession(session: string): Promise<boolean> {
+    await this.ensureDaemonRunning();
+
+    try {
+      const response = await fetch(`http://${this.host}:${this.port}/close`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ session }),
+      });
+
+      const result = await response.json();
+      return result.closed;
+    } catch {
+      return false;
+    }
+  }
+
+  async listSessions(): Promise<any[]> {
+    await this.ensureDaemonRunning();
+
+    try {
+      const response = await fetch(`http://${this.host}:${this.port}/sessions`);
+      const result = await response.json();
+      return result.sessions || [];
+    } catch {
+      return [];
+    }
+  }
+}