@poolzin/pool-bot 2026.3.13 → 2026.3.15

package/extensions/page-agent/node_modules/.bin/tsx

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/tsx@4.21.0/node_modules/tsx/dist/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/tsx@4.21.0/node_modules/tsx/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/tsx@4.21.0/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/tsx@4.21.0/node_modules/tsx/dist/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/tsx@4.21.0/node_modules/tsx/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/tsx@4.21.0/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../../../../node_modules/.pnpm/tsx@4.21.0/node_modules/tsx/dist/cli.mjs" "$@"
+else
+  exec node  "$basedir/../../../../node_modules/.pnpm/tsx@4.21.0/node_modules/tsx/dist/cli.mjs" "$@"
+fi

package/extensions/page-agent/node_modules/.bin/vitest

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/vitest@3.2.4_@types+node@22.19.15_@vitest+browser@4.0.18_vite@7.3.1_@types+node@25.2.3__6cb5e51e836830cd2cffacfc8438d429/node_modules/vitest/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/vitest@3.2.4_@types+node@22.19.15_@vitest+browser@4.0.18_vite@7.3.1_@types+node@25.2.3__6cb5e51e836830cd2cffacfc8438d429/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/vitest@3.2.4_@types+node@22.19.15_@vitest+browser@4.0.18_vite@7.3.1_@types+node@25.2.3__6cb5e51e836830cd2cffacfc8438d429/node_modules/vitest/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/vitest@3.2.4_@types+node@22.19.15_@vitest+browser@4.0.18_vite@7.3.1_@types+node@25.2.3__6cb5e51e836830cd2cffacfc8438d429/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../vitest/vitest.mjs" "$@"
+else
+  exec node  "$basedir/../vitest/vitest.mjs" "$@"
+fi

package/extensions/page-agent/node_modules/.bin/yaml

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/yaml@2.8.2/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/yaml@2.8.2/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../../../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/bin.mjs" "$@"
+else
+  exec node  "$basedir/../../../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/bin.mjs" "$@"
+fi

package/extensions/page-agent/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@poolbot/page-agent",
+  "version": "2026.3.13",
+  "description": "Page Agent - GUI Browser Automation for PoolBot with AI-powered web interaction",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./core": "./dist/core/index.js",
+    "./controller": "./dist/controller/index.js",
+    "./tools": "./dist/tools/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.0",
+    "playwright": "^1.50.0",
+    "zod": "^3.22.0",
+    "chalk": "^5.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  },
+  "peerDependencies": {
+    "poolbot": "workspace:*"
+  },
+  "poolbot": {
+    "plugin": true,
+    "config": {
+      "schema": "./dist/config/schema.js"
+    }
+  },
+  "keywords": ["browser", "automation", "gui", "playwright", "ai"],
+  "author": "PoolBot Team",
+  "license": "MIT"
+}

package/extensions/page-agent/poolbot.plugin.json

@@ -0,0 +1,24 @@
+{
+  "id": "page-agent",
+  "name": "Page Agent",
+  "description": "GUI Browser Automation for PoolBot with AI-powered web interaction",
+  "version": "2026.3.14",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "headless": {
+        "type": "boolean",
+        "default": true,
+        "description": "Run browser in headless mode"
+      },
+      "viewport": {
+        "type": "object",
+        "properties": {
+          "width": { "type": "number", "default": 1280 },
+          "height": { "type": "number", "default": 720 }
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,517 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { PageAgentService } from './PageAgentService.js'
+import { PoolBotPageController } from './PoolBotPageController.js'
+import type { PageAgentConfig, PageAgentTool, PageAgentLLMConfig } from './types.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 { browserNavigate } from '../../../src/browser/client-actions.js'
+
+describe('PageAgentService', () => {
+  let controller: PoolBotPageController
+  let config: PageAgentConfig
+  let service: PageAgentService
+  let mockFetch: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    
+    controller = new PoolBotPageController({
+      browserBaseUrl: 'http://localhost:9222',
+      profile: 'test-profile',
+    })
+
+    const llmConfig: PageAgentLLMConfig = {
+      provider: 'openai',
+      baseURL: 'http://localhost:11434/v1',
+      apiKey: 'test-key',
+      model: 'qwen2.5:14b',
+      temperature: 0.7,
+    }
+
+    config = {
+      llm: llmConfig,
+      maxSteps: 10,
+    }
+
+    service = new PageAgentService(config, controller)
+    
+    // Create a proper mock for fetch
+    mockFetch = vi.fn()
+    global.fetch = mockFetch as unknown as typeof fetch
+  })
+
+  afterEach(() => {
+    service.dispose()
+  })
+
+  describe('constructor', () => {
+    it('should create service with valid config', () => {
+      expect(service).toBeDefined()
+      expect(service.id).toBeDefined()
+      expect(service.config).toBe(config)
+      expect(service.status).toBe('idle')
+    })
+
+    it('should generate unique IDs', () => {
+      const service2 = new PageAgentService(config, controller)
+      expect(service.id).not.toBe(service2.id)
+      service2.dispose()
+    })
+
+    it('should apply custom tools', () => {
+      const customTool: PageAgentTool = {
+        name: 'custom_tool',
+        description: 'A custom tool',
+        inputSchema: { type: 'object', properties: {} },
+        execute: vi.fn().mockResolvedValue('success'),
+      }
+
+      const configWithCustomTool: PageAgentConfig = {
+        ...config,
+        customTools: {
+          custom_tool: customTool,
+        },
+      }
+
+      const serviceWithCustom = new PageAgentService(configWithCustomTool, controller)
+      expect(serviceWithCustom).toBeDefined()
+      serviceWithCustom.dispose()
+    })
+
+    it('should remove tools when set to null', () => {
+      const configWithRemovedTool: PageAgentConfig = {
+        ...config,
+        customTools: {
+          navigate: null,
+        },
+      }
+
+      const serviceWithRemoved = new PageAgentService(configWithRemovedTool, controller)
+      expect(serviceWithRemoved).toBeDefined()
+      serviceWithRemoved.dispose()
+    })
+  })
+
+  describe('execute', () => {
+    it('should throw error if disposed', async () => {
+      service.dispose()
+      await expect(service.execute('test task')).rejects.toThrow('disposed')
+    })
+
+    it('should throw error if task is empty', async () => {
+      await expect(service.execute('')).rejects.toThrow('Task is required')
+    })
+
+    it('should set status to running when starting', async () => {
+      // Mock LLM response for immediate completion
+      const mockLLMResponse = {
+        choices: [{
+          message: {
+            tool_calls: [{
+              function: {
+                name: 'AgentOutput',
+                arguments: JSON.stringify({
+                  evaluation_previous_goal: 'Starting task',
+                  memory: '',
+                  next_goal: 'Complete task',
+                  action: { done: { success: true, answer: 'Done' } },
+                }),
+              },
+            }],
+          },
+        }],
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockLLMResponse),
+      })
+
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Test content',
+        format: 'ai',
+        targetId: 'test-target',
+      })
+
+      const statusChanges: string[] = []
+      service.addEventListener('statuschange', () => {
+        statusChanges.push(service.status)
+      })
+
+      await service.execute('test task')
+
+      expect(statusChanges).toContain('running')
+      expect(statusChanges).toContain('completed')
+    })
+
+    it('should complete task successfully', async () => {
+      const mockLLMResponse = {
+        choices: [{
+          message: {
+            tool_calls: [{
+              function: {
+                name: 'AgentOutput',
+                arguments: JSON.stringify({
+                  evaluation_previous_goal: 'Task completed',
+                  memory: 'Test memory',
+                  next_goal: 'Finish',
+                  action: { done: { success: true, answer: 'Task completed successfully' } },
+                }),
+              },
+            }],
+          },
+        }],
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockLLMResponse),
+      })
+
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Test content',
+        format: 'ai',
+        targetId: 'test-target',
+      })
+
+      const result = await service.execute('test task')
+
+      expect(result.success).toBe(true)
+      expect(result.data).toBe('Task completed successfully')
+      expect(result.totalSteps).toBe(1)
+      expect(result.duration).toBeGreaterThan(0)
+    })
+
+    it('should handle task failure', async () => {
+      const mockLLMResponse = {
+        choices: [{
+          message: {
+            tool_calls: [{
+              function: {
+                name: 'AgentOutput',
+                arguments: JSON.stringify({
+                  evaluation_previous_goal: 'Task failed',
+                  memory: '',
+                  next_goal: 'Abort',
+                  action: { done: { success: false, answer: 'Could not complete' } },
+                }),
+              },
+            }],
+          },
+        }],
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockLLMResponse),
+      })
+
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Test content',
+        format: 'ai',
+        targetId: 'test-target',
+      })
+
+      const result = await service.execute('test task')
+
+      expect(result.success).toBe(false)
+      expect(result.data).toBe('Could not complete')
+    })
+
+    it('should respect max steps limit', async () => {
+      const configWithLowMaxSteps: PageAgentConfig = {
+        ...config,
+        maxSteps: 2,
+      }
+
+      const serviceWithLowMax = new PageAgentService(configWithLowMaxSteps, controller)
+
+      const mockLLMResponse = {
+        choices: [{
+          message: {
+            tool_calls: [{
+              function: {
+                name: 'AgentOutput',
+                arguments: JSON.stringify({
+                  evaluation_previous_goal: 'Step executed',
+                  memory: '',
+                  next_goal: 'Continue',
+                  action: { navigate: { url: 'http://example.com' } },
+                }),
+              },
+            }],
+          },
+        }],
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockLLMResponse),
+      })
+
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Test content',
+        format: 'ai',
+        targetId: 'test-target',
+      })
+
+      vi.mocked(browserNavigate).mockResolvedValue({
+        ok: true,
+        targetId: 'test-target',
+      })
+
+      const result = await serviceWithLowMax.execute('test task')
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('Step count exceeded')
+      expect(result.totalSteps).toBe(2)
+
+      serviceWithLowMax.dispose()
+    })
+
+    it('should handle LLM API errors', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+      })
+
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Test content',
+        format: 'ai',
+        targetId: 'test-target',
+      })
+
+      const result = await service.execute('test task')
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('LLM API error')
+    })
+
+    it('should handle missing tool calls in LLM response', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{
+            message: {
+              content: 'No tool call',
+            },
+          }],
+        }),
+      })
+
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Test content',
+        format: 'ai',
+        targetId: 'test-target',
+      })
+
+      const result = await service.execute('test task')
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('No tool call')
+    })
+
+    it('should call lifecycle hooks', async () => {
+      const onBeforeTask = vi.fn()
+      const onAfterTask = vi.fn()
+      const onBeforeStep = vi.fn()
+      const onAfterStep = vi.fn()
+
+      const configWithHooks: PageAgentConfig = {
+        ...config,
+        onBeforeTask,
+        onAfterTask,
+        onBeforeStep,
+        onAfterStep,
+      }
+
+      const serviceWithHooks = new PageAgentService(configWithHooks, controller)
+
+      const mockLLMResponse = {
+        choices: [{
+          message: {
+            tool_calls: [{
+              function: {
+                name: 'AgentOutput',
+                arguments: JSON.stringify({
+                  evaluation_previous_goal: 'Done',
+                  memory: '',
+                  next_goal: 'Finish',
+                  action: { done: { success: true, answer: 'Done' } },
+                }),
+              },
+            }],
+          },
+        }],
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockLLMResponse),
+      })
+
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Test content',
+        format: 'ai',
+        targetId: 'test-target',
+      })
+
+      await serviceWithHooks.execute('test task')
+
+      expect(onBeforeTask).toHaveBeenCalledWith(serviceWithHooks)
+      expect(onAfterTask).toHaveBeenCalled()
+      expect(onBeforeStep).toHaveBeenCalledWith(serviceWithHooks, 0)
+      expect(onAfterStep).toHaveBeenCalled()
+
+      serviceWithHooks.dispose()
+    })
+  })
+
+  describe('stop', () => {
+    it('should abort the current task', () => {
+      service.stop()
+      // Should not throw
+    })
+  })
+
+  describe('dispose', () => {
+    it('should dispose the service', () => {
+      const onDispose = vi.fn()
+      const configWithDispose: PageAgentConfig = {
+        ...config,
+        onDispose,
+      }
+
+      const serviceWithDispose = new PageAgentService(configWithDispose, controller)
+      serviceWithDispose.dispose()
+
+      expect(serviceWithDispose.disposed).toBe(true)
+      expect(onDispose).toHaveBeenCalledWith(serviceWithDispose)
+    })
+
+    it('should dispatch dispose event', () => {
+      const disposeHandler = vi.fn()
+      service.addEventListener('dispose', disposeHandler)
+
+      service.dispose()
+
+      expect(disposeHandler).toHaveBeenCalled()
+    })
+  })
+
+  describe('pushObservation', () => {
+    it('should add observations', () => {
+      service.pushObservation('Test observation')
+      // The observations are private, but we can verify through behavior
+      expect(service).toBeDefined()
+    })
+  })
+
+  describe('event handling', () => {
+    it('should emit history change events', async () => {
+      const historyHandler = vi.fn()
+      service.addEventListener('historychange', historyHandler)
+
+      const mockLLMResponse = {
+        choices: [{
+          message: {
+            tool_calls: [{
+              function: {
+                name: 'AgentOutput',
+                arguments: JSON.stringify({
+                  evaluation_previous_goal: 'Done',
+                  memory: '',
+                  next_goal: 'Finish',
+                  action: { done: { success: true, answer: 'Done' } },
+                }),
+              },
+            }],
+          },
+        }],
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockLLMResponse),
+      })
+
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Test content',
+        format: 'ai',
+        targetId: 'test-target',
+      })
+
+      await service.execute('test task')
+
+      expect(historyHandler).toHaveBeenCalled()
+    })
+
+    it('should emit activity events', async () => {
+      const activityHandler = vi.fn()
+      service.addEventListener('activity', activityHandler)
+
+      const mockLLMResponse = {
+        choices: [{
+          message: {
+            tool_calls: [{
+              function: {
+                name: 'AgentOutput',
+                arguments: JSON.stringify({
+                  evaluation_previous_goal: 'Done',
+                  memory: '',
+                  next_goal: 'Finish',
+                  action: { done: { success: true, answer: 'Done' } },
+                }),
+              },
+            }],
+          },
+        }],
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockLLMResponse),
+      })
+
+      vi.mocked(browserSnapshot).mockResolvedValue({
+        ok: true,
+        url: 'http://example.com',
+        snapshot: 'Test content',
+        format: 'ai',
+        targetId: 'test-target',
+      })
+
+      await service.execute('test task')
+
+      expect(activityHandler).toHaveBeenCalled()
+    })
+  })
+})