@poolzin/pool-bot 2026.3.11 → 2026.3.14

package/extensions/page-agent/src/PoolBotPageController.test.ts

@@ -0,0 +1,358 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { PoolBotPageController } from './PoolBotPageController.js'
+
+// Mock the browser client modules
+vi.mock('../../../src/browser/client.js', () => ({
+  browserSnapshot: vi.fn(),
+}))
+
+vi.mock('../../../src/browser/client-actions.js', () => ({
+  browserAct: vi.fn(),
+  browserNavigate: vi.fn(),
+  browserScreenshotAction: vi.fn(),
+}))
+
+import { browserSnapshot } from '../../../src/browser/client.js'
+import { browserAct, browserNavigate, browserScreenshotAction } from '../../../src/browser/client-actions.js'
+
+describe('PoolBotPageController', () => {
+  let controller: PoolBotPageController
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    controller = new PoolBotPageController({
+      browserBaseUrl: 'http://localhost:9222',
+      profile: 'test-profile',
+    })
+  })
+
+  describe('constructor', () => {
+    it('should create controller with default config', () => {
+      const defaultController = new PoolBotPageController()
+      expect(defaultController).toBeDefined()
+    })
+
+    it('should create controller with custom config', () => {
+      expect(controller).toBeDefined()
+    })
+
+    it('should store targetId from config', () => {
+      const controllerWithTarget = new PoolBotPageController({
+        targetId: 'test-target-id',
+      })
+      expect(controllerWithTarget.getTargetId()).toBe('test-target-id')
+    })
+  })
+
+  describe('getBrowserState', () => {
+    it('should return browser state in ai format', async () => {
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Test page content',
+        format: 'ai',
+        targetId: 'test-target',
+      })
+
+      const state = await controller.getBrowserState()
+
+      expect(state.url).toBe('http://example.com')
+      expect(state.content).toBe('Test page content')
+      expect(state.snapshot).toBe('Test page content')
+    })
+
+    it('should return browser state in aria format', async () => {
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        nodes: [
+          { ref: '1', role: 'heading', name: 'Title', depth: 0 },
+          { ref: '2', role: 'button', name: 'Click me', depth: 1 },
+        ],
+        format: 'aria',
+        targetId: 'test-target',
+      })
+
+      const state = await controller.getBrowserState()
+
+      expect(state.url).toBe('http://example.com')
+      expect(state.content).toContain('[1] heading: Title')
+      expect(state.content).toContain('[2] button: Click me')
+    })
+
+    it('should update targetId from snapshot', async () => {
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Content',
+        format: 'ai',
+        targetId: 'new-target-id',
+      })
+
+      await controller.getBrowserState()
+
+      expect(controller.getTargetId()).toBe('new-target-id')
+    })
+
+    it('should throw error if snapshot fails', async () => {
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: false,
+      } as never)
+
+      await expect(controller.getBrowserState()).rejects.toThrow('Failed to get browser snapshot')
+    })
+  })
+
+  describe('navigate', () => {
+    it('should navigate to URL successfully', async () => {
+      vi.mocked(browserNavigate).mockResolvedValue({
+        ok: true,
+        targetId: 'new-target',
+      })
+
+      const result = await controller.navigate('http://example.com')
+
+      expect(result.success).toBe(true)
+      expect(result.message).toContain('Navigated to')
+      expect(controller.getTargetId()).toBe('new-target')
+    })
+
+    it('should handle navigation failure', async () => {
+      vi.mocked(browserNavigate).mockRejectedValue(new Error('Navigation failed'))
+
+      const result = await controller.navigate('http://example.com')
+
+      expect(result.success).toBe(false)
+      expect(result.message).toContain('Failed to navigate')
+    })
+  })
+
+  describe('clickElement', () => {
+    it('should click element successfully', async () => {
+      vi.mocked(browserAct).mockResolvedValue({
+        ok: true,
+        targetId: 'test-target',
+      })
+
+      const result = await controller.clickElement('element-ref-1')
+
+      expect(result.success).toBe(true)
+      expect(browserAct).toHaveBeenCalledWith(
+        'http://localhost:9222',
+        {
+          kind: 'click',
+          ref: 'element-ref-1',
+          targetId: undefined,
+        },
+        { profile: 'test-profile' }
+      )
+    })
+
+    it('should handle click failure', async () => {
+      vi.mocked(browserAct).mockRejectedValue(new Error('Click failed'))
+
+      const result = await controller.clickElement('element-ref-1')
+
+      expect(result.success).toBe(false)
+      expect(result.message).toContain('Action failed')
+    })
+  })
+
+  describe('inputText', () => {
+    it('should input text successfully', async () => {
+      vi.mocked(browserAct).mockResolvedValue({
+        ok: true,
+        targetId: 'test-target',
+      })
+
+      const result = await controller.inputText('input-ref', 'test text')
+
+      expect(result.success).toBe(true)
+      expect(browserAct).toHaveBeenCalledWith(
+        'http://localhost:9222',
+        {
+          kind: 'type',
+          ref: 'input-ref',
+          text: 'test text',
+          targetId: undefined,
+        },
+        { profile: 'test-profile' }
+      )
+    })
+  })
+
+  describe('selectOption', () => {
+    it('should select option successfully', async () => {
+      vi.mocked(browserAct).mockResolvedValue({
+        ok: true,
+        targetId: 'test-target',
+      })
+
+      const result = await controller.selectOption('select-ref', 'option-value')
+
+      expect(result.success).toBe(true)
+      expect(browserAct).toHaveBeenCalledWith(
+        'http://localhost:9222',
+        {
+          kind: 'select',
+          ref: 'select-ref',
+          values: ['option-value'],
+          targetId: undefined,
+        },
+        { profile: 'test-profile' }
+      )
+    })
+  })
+
+  describe('scroll', () => {
+    it('should scroll down by default', async () => {
+      vi.mocked(browserAct).mockResolvedValue({
+        ok: true,
+        targetId: 'test-target',
+      })
+
+      const result = await controller.scroll({})
+
+      expect(result.success).toBe(true)
+      expect(browserAct).toHaveBeenCalledWith(
+        'http://localhost:9222',
+        expect.objectContaining({
+          kind: 'evaluate',
+          fn: expect.stringContaining('scrollBy'),
+        }),
+        { profile: 'test-profile' }
+      )
+    })
+
+    it('should scroll up when specified', async () => {
+      vi.mocked(browserAct).mockResolvedValue({
+        ok: true,
+        targetId: 'test-target',
+      })
+
+      const result = await controller.scroll({ down: false })
+
+      expect(result.success).toBe(true)
+      expect(browserAct).toHaveBeenCalledWith(
+        'http://localhost:9222',
+        expect.objectContaining({
+          kind: 'evaluate',
+          fn: expect.stringContaining('-500'),
+        }),
+        { profile: 'test-profile' }
+      )
+    })
+
+    it('should use custom amount', async () => {
+      vi.mocked(browserAct).mockResolvedValue({
+        ok: true,
+        targetId: 'test-target',
+      })
+
+      const result = await controller.scroll({ amount: 1000 })
+
+      expect(result.success).toBe(true)
+      expect(browserAct).toHaveBeenCalledWith(
+        'http://localhost:9222',
+        expect.objectContaining({
+          fn: expect.stringContaining('1000'),
+        }),
+        { profile: 'test-profile' }
+      )
+    })
+  })
+
+  describe('wait', () => {
+    it('should wait for specified seconds', async () => {
+      const start = Date.now()
+      const result = await controller.wait(0.1) // 100ms
+      const elapsed = Date.now() - start
+
+      expect(result.success).toBe(true)
+      expect(result.message).toContain('Waited for 0.1 seconds')
+      expect(elapsed).toBeGreaterThanOrEqual(90)
+    })
+  })
+
+  describe('executeJavaScript', () => {
+    it('should execute JavaScript successfully', async () => {
+      vi.mocked(browserAct).mockResolvedValue({
+        ok: true,
+        targetId: 'test-target',
+      })
+
+      const result = await controller.executeJavaScript('document.title')
+
+      expect(result.success).toBe(true)
+      expect(browserAct).toHaveBeenCalledWith(
+        'http://localhost:9222',
+        {
+          kind: 'evaluate',
+          fn: 'document.title',
+          targetId: undefined,
+        },
+        { profile: 'test-profile' }
+      )
+    })
+  })
+
+  describe('screenshot', () => {
+    it('should take screenshot successfully', async () => {
+      vi.mocked(browserScreenshotAction).mockResolvedValue({
+        ok: true,
+        targetId: 'test-target',
+        path: 'base64-screenshot-data',
+      })
+
+      const result = await controller.screenshot()
+
+      expect(result.success).toBe(true)
+      expect(result.base64).toBe('base64-screenshot-data')
+      expect(result.message).toContain('Screenshot captured')
+    })
+
+    it('should handle screenshot failure', async () => {
+      vi.mocked(browserScreenshotAction).mockRejectedValue(new Error('Screenshot failed'))
+
+      const result = await controller.screenshot()
+
+      expect(result.success).toBe(false)
+      expect(result.message).toContain('Screenshot failed')
+    })
+
+    it('should pass fullPage option', async () => {
+      vi.mocked(browserScreenshotAction).mockResolvedValue({
+        ok: true,
+        targetId: 'test-target',
+        path: 'base64-data',
+      })
+
+      await controller.screenshot({ fullPage: true })
+
+      expect(browserScreenshotAction).toHaveBeenCalledWith(
+        'http://localhost:9222',
+        expect.objectContaining({
+          fullPage: true,
+          type: 'png',
+        })
+      )
+    })
+  })
+
+  describe('getToolContext', () => {
+    it('should return tool context', () => {
+      const context = controller.getToolContext()
+
+      expect(context.browserBaseUrl).toBe('http://localhost:9222')
+      expect(context.profile).toBe('test-profile')
+      expect(context.targetId).toBeUndefined()
+    })
+  })
+
+  describe('setTargetId', () => {
+    it('should update targetId', () => {
+      controller.setTargetId('new-target')
+      expect(controller.getTargetId()).toBe('new-target')
+    })
+  })
+})

package/extensions/page-agent/src/PoolBotPageController.ts

@@ -0,0 +1,245 @@
+/**
+ * PoolBot Page Controller
+ * 
+ * Adapter that wraps PoolBot's native browser client to provide
+ * the PageController interface expected by Page Agent.
+ */
+
+import {
+  browserSnapshot,
+} from '../../../src/browser/client.js';
+import {
+  browserAct,
+  browserNavigate,
+  browserScreenshotAction,
+  type BrowserActRequest,
+} from '../../../src/browser/client-actions.js';
+import type { BrowserState, ToolContext } from './types.js';
+
+export interface PoolBotPageControllerConfig {
+  browserBaseUrl?: string;
+  profile?: string;
+  targetId?: string;
+}
+
+export class PoolBotPageController {
+  private config: PoolBotPageControllerConfig;
+  private currentTargetId: string | undefined;
+
+  constructor(config: PoolBotPageControllerConfig = {}) {
+    this.config = config;
+    this.currentTargetId = config.targetId;
+  }
+
+  /**
+   * Get current browser state for LLM consumption
+   */
+  async getBrowserState(): Promise<BrowserState> {
+    const snapshot = await browserSnapshot(this.config.browserBaseUrl, {
+      format: 'ai',
+      profile: this.config.profile,
+      targetId: this.currentTargetId,
+      interactive: true,
+      labels: true,
+    });
+
+    if (!snapshot.ok) {
+      throw new Error('Failed to get browser snapshot');
+    }
+
+    this.currentTargetId = snapshot.targetId;
+
+    // Handle both ai and aria formats
+    if (snapshot.format === 'ai') {
+      return {
+        url: snapshot.url,
+        title: '', // Extract from snapshot if needed
+        content: snapshot.snapshot,
+        snapshot: snapshot.snapshot,
+      };
+    } else {
+      // aria format - convert to string representation
+      const content = snapshot.nodes.map(n => `[${n.ref}] ${n.role}: ${n.name}`).join('\n');
+      return {
+        url: snapshot.url,
+        title: '',
+        content,
+        snapshot: content,
+      };
+    }
+  }
+
+  /**
+   * Navigate to a URL
+   */
+  async navigate(url: string): Promise<{ success: boolean; message: string }> {
+    try {
+      const result = await browserNavigate(this.config.browserBaseUrl, {
+        url,
+        profile: this.config.profile,
+        targetId: this.currentTargetId,
+      });
+      
+      this.currentTargetId = result.targetId;
+      
+      return {
+        success: true,
+        message: `Navigated to ${url}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to navigate: ${error}`,
+      };
+    }
+  }
+
+  /**
+   * Click element by ref
+   */
+  async clickElement(ref: string): Promise<{ success: boolean; message: string }> {
+    return this.executeAction({
+      kind: 'click',
+      ref,
+      targetId: this.currentTargetId,
+    });
+  }
+
+  /**
+   * Type text into element
+   */
+  async inputText(ref: string, text: string): Promise<{ success: boolean; message: string }> {
+    return this.executeAction({
+      kind: 'type',
+      ref,
+      text,
+      targetId: this.currentTargetId,
+    });
+  }
+
+  /**
+   * Select option from dropdown
+   */
+  async selectOption(ref: string, value: string): Promise<{ success: boolean; message: string }> {
+    return this.executeAction({
+      kind: 'select',
+      ref,
+      values: [value],
+      targetId: this.currentTargetId,
+    });
+  }
+
+  /**
+   * Scroll page
+   */
+  async scroll(options: {
+    down?: boolean;
+    amount?: number;
+  }): Promise<{ success: boolean; message: string }> {
+    const direction = options.down !== false ? 1 : -1;
+    const amount = options.amount || 500;
+    
+    return this.executeAction({
+      kind: 'evaluate',
+      fn: `window.scrollBy(0, ${amount * direction})`,
+      targetId: this.currentTargetId,
+    });
+  }
+
+  /**
+   * Wait for a specified time
+   */
+  async wait(seconds: number): Promise<{ success: boolean; message: string }> {
+    await new Promise(resolve => setTimeout(resolve, seconds * 1000));
+    return {
+      success: true,
+      message: `Waited for ${seconds} seconds`,
+    };
+  }
+
+  /**
+   * Execute JavaScript on the page
+   */
+  async executeJavaScript(script: string): Promise<{ success: boolean; message: string }> {
+    return this.executeAction({
+      kind: 'evaluate',
+      fn: script,
+      targetId: this.currentTargetId,
+    });
+  }
+
+  /**
+   * Get tool context for executing actions
+   */
+  getToolContext(): ToolContext {
+    return {
+      browserBaseUrl: this.config.browserBaseUrl,
+      profile: this.config.profile,
+      targetId: this.currentTargetId,
+    };
+  }
+
+  /**
+   * Execute a browser action
+   */
+  private async executeAction(action: BrowserActRequest): Promise<{ success: boolean; message: string }> {
+    try {
+      const result = await browserAct(this.config.browserBaseUrl, action, {
+        profile: this.config.profile,
+      });
+      
+      if (result.targetId) {
+        this.currentTargetId = result.targetId;
+      }
+      
+      return {
+        success: true,
+        message: `Action completed successfully`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Action failed: ${error}`,
+      };
+    }
+  }
+
+  /**
+   * Update target ID
+   */
+  setTargetId(targetId: string): void {
+    this.currentTargetId = targetId;
+  }
+
+  /**
+   * Get current target ID
+   */
+  getTargetId(): string | undefined {
+    return this.currentTargetId;
+  }
+
+  /**
+   * Take a screenshot of the current page
+   */
+  async screenshot(options?: { fullPage?: boolean }): Promise<{ success: boolean; base64?: string; message: string }> {
+    try {
+      const result = await browserScreenshotAction(this.config.browserBaseUrl, {
+        profile: this.config.profile,
+        targetId: this.currentTargetId,
+        fullPage: options?.fullPage,
+        type: 'png',
+      });
+
+      return {
+        success: true,
+        base64: result.path,
+        message: `Screenshot captured successfully`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Screenshot failed: ${error}`,
+      };
+    }
+  }
+}

package/extensions/page-agent/src/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Page Agent Integration for PoolBot
+ * 
+ * This module provides AI-powered browser automation by integrating
+ * the Page Agent core logic with PoolBot's native browser system.
+ * 
+ * Instead of creating a separate browser instance, this integration
+ * leverages PoolBot's existing CDP/Playwright infrastructure for
+ * efficient resource usage and seamless operation.
+ */
+
+export { PageAgentService } from './PageAgentService.js';
+export { PoolBotPageController } from './PoolBotPageController.js';
+export { createPageAgentTools } from './tools.js';
+export type { 
+  PageAgentConfig, 
+  PageAgentExecutionResult,
+  PageAgentStep,
+  PageAgentStatus 
+} from './types.js';