Web Qa Bot

# Dependencies
node_modules/

# Build output
dist/

# Screenshots
screenshots/

# Test results
*.results.json

# OS files
.DS_Store
Thumbs.db

# IDE
.vscode/
.idea/
*.swp
*.swo

# Logs
*.log
npm-debug.log*

# Coverage
coverage/

# Environment
.env
.env.local

#!/usr/bin/env node

import '../dist/cli.js'

{
  "name": "web-qa-bot",
  "version": "0.1.2",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "web-qa-bot",
      "version": "0.1.2",
      "license": "MIT",
      "dependencies": {
        "yaml": "^2.3.4"
      },
      "bin": {
        "web-qa-bot": "bin/web-qa-bot.js"
      },
      "devDependencies": {
        "@types/node": "^20.10.0",
        "typescript": "^5.3.0"
      },
      "engines": {
        "node": ">=18.0.0"
      },
      "peerDependencies": {
        "agent-browser": ">=0.7.0"
      },
      "peerDependenciesMeta": {
        "agent-browser": {
          "optional": false
        }
      }
    },
    "node_modules/@types/node": {
      "version": "20.19.30",
      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.30.tgz",
      "integrity": "sha512-WJtwWJu7UdlvzEAUm484QNg5eAoq5QR08KDNx7g45Usrs2NtOPiX8ugDqmKdXkyL03rBqU5dYNYVQetEpBHq2g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "undici-types": "~6.21.0"
      }
    },
    "node_modules/agent-browser": {
      "version": "0.8.4",
      "resolved": "https://registry.npmjs.org/agent-browser/-/agent-browser-0.8.4.tgz",
      "integrity": "sha512-zs2Lt8dmawlEtiBSaAzxxij0lTo1R9rSViKnGtA14CebAC3rr0dOu7Em+j2tSmLrvUsxXs42xpPJ1395b4WJ6w==",
      "hasInstallScript": true,
      "license": "Apache-2.0",
      "peer": true,
      "dependencies": {
        "playwright-core": "^1.57.0",
        "ws": "^8.19.0",
        "zod": "^3.22.4"
      },
      "bin": {
        "agent-browser": "bin/agent-browser.js"
      }
    },
    "node_modules/playwright-core": {
      "version": "1.58.0",
      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.58.0.tgz",
      "integrity": "sha512-aaoB1RWrdNi3//rOeKuMiS65UCcgOVljU46At6eFcOFPFHWtd2weHRRow6z/n+Lec0Lvu0k9ZPKJSjPugikirw==",
      "license": "Apache-2.0",
      "peer": true,
      "bin": {
        "playwright-core": "cli.js"
      },
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/typescript": {
      "version": "5.9.3",
      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
      "dev": true,
      "license": "Apache-2.0",
      "bin": {
        "tsc": "bin/tsc",
        "tsserver": "bin/tsserver"
      },
      "engines": {
        "node": ">=14.17"
      }
    },
    "node_modules/undici-types": {
      "version": "6.21.0",
      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/ws": {
      "version": "8.19.0",
      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
      "license": "MIT",
      "peer": true,
      "engines": {
        "node": ">=10.0.0"
      },
      "peerDependencies": {
        "bufferutil": "^4.0.1",
        "utf-8-validate": ">=5.0.2"
      },
      "peerDependenciesMeta": {
        "bufferutil": {
          "optional": true
        },
        "utf-8-validate": {
          "optional": true
        }
      }
    },
    "node_modules/yaml": {
      "version": "2.8.2",
      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.2.tgz",
      "integrity": "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==",
      "license": "ISC",
      "bin": {
        "yaml": "bin.mjs"
      },
      "engines": {
        "node": ">= 14.6"
      },
      "funding": {
        "url": "https://github.com/sponsors/eemeli"
      }
    },
    "node_modules/zod": {
      "version": "3.25.76",
      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
      "license": "MIT",
      "peer": true,
      "funding": {
        "url": "https://github.com/sponsors/colinhacks"
      }
    }
  }
}

{
  "name": "web-qa-bot",
  "version": "0.1.2",
  "description": "Automated QA for web apps using AI. Smoke tests, accessibility checks, visual regression. Drop-in replacement for manual QA. Works with Playwright, Cursor, Claude. QA without the QA team.",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
  "bin": {
    "web-qa-bot": "./bin/web-qa-bot.js"
  },
  "scripts": {
    "build": "tsc",
    "watch": "tsc --watch",
    "test": "node --test dist/**/*.test.js",
    "prepublishOnly": "npm run build"
  },
  "keywords": [
    "automated-qa",
    "ai-testing",
    "smoke-test",
    "accessibility-testing",
    "visual-regression",
    "ci-testing",
    "playwright-alternative",
    "selenium-alternative",
    "e2e-testing",
    "qa",
    "testing",
    "automation",
    "browser",
    "web-testing",
    "ai",
    "ai-agent",
    "vibe-coding",
    "cursor",
    "claude",
    "gpt",
    "copilot",
    "mcp",
    "langchain",
    "llm",
    "devops",
    "ci-cd",
    "github-actions",
    "clawdbot",
    "moltbot"
  ],
  "author": "NextFrontierBuilds",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/NextFrontierBuilds/web-qa-bot.git"
  },
  "engines": {
    "node": ">=18.0.0"
  },
  "dependencies": {
    "yaml": "^2.3.4"
  },
  "devDependencies": {
    "@types/node": "^20.10.0",
    "typescript": "^5.3.0"
  },
  "peerDependencies": {
    "agent-browser": ">=0.7.0"
  },
  "peerDependenciesMeta": {
    "agent-browser": {
      "optional": false
    }
  },
  "files": [
    "dist",
    "bin",
    "templates",
    "README.md",
    "SKILL.md"
  ]
}

/**
 * Test assertions for web QA
 */

import type { Snapshot, ConsoleEvent } from './types.js'
import { findByRole, findByText, elementExists, detectModals } from './utils/snapshot.js'

export class AssertionError extends Error {
  constructor(message: string, public actual?: unknown, public expected?: unknown) {
    super(message)
    this.name = 'AssertionError'
  }
}

/**
 * Assert element is visible in snapshot
 */
export function expectVisible(snapshot: Snapshot, selector: string): void {
  if (!elementExists(snapshot, selector)) {
    throw new AssertionError(
      `Element not visible: ${selector}`,
      'not found',
      'visible'
    )
  }
}

/**
 * Assert element is NOT visible
 */
export function expectNotVisible(snapshot: Snapshot, selector: string): void {
  if (elementExists(snapshot, selector)) {
    throw new AssertionError(
      `Element should not be visible: ${selector}`,
      'visible',
      'not visible'
    )
  }
}

/**
 * Assert element has text
 */
export function expectText(
  snapshot: Snapshot,
  selector: string,
  text: string,
  options: { contains?: boolean } = {}
): void {
  let found: { name: string } | undefined
  
  if (selector.startsWith('@')) {
    found = snapshot.refs.get(selector)
  } else {
    found = findByText(snapshot, selector)
  }
  
  if (!found) {
    throw new AssertionError(
      `Element not found: ${selector}`,
      'not found',
      text
    )
  }
  
  const actual = found.name
  const matches = options.contains 
    ? actual.toLowerCase().includes(text.toLowerCase())
    : actual.toLowerCase() === text.toLowerCase()
  
  if (!matches) {
    throw new AssertionError(
      `Text mismatch for ${selector}`,
      actual,
      text
    )
  }
}

/**
 * Assert URL matches
 */
export function expectUrl(
  snapshot: Snapshot,
  expected: string | { contains?: string; matches?: RegExp }
): void {
  const actual = snapshot.url
  
  if (typeof expected === 'string') {
    if (actual !== expected) {
      throw new AssertionError('URL mismatch', actual, expected)
    }
  } else if (expected.contains) {
    if (!actual.includes(expected.contains)) {
      throw new AssertionError(
        `URL does not contain expected string`,
        actual,
        expected.contains
      )
    }
  } else if (expected.matches) {
    if (!expected.matches.test(actual)) {
      throw new AssertionError(
        `URL does not match pattern`,
        actual,
        expected.matches.toString()
      )
    }
  }
}

/**
 * Assert element count
 */
export function expectCount(
  snapshot: Snapshot,
  role: string,
  expected: number | { min?: number; max?: number }
): void {
  let count = 0
  for (const [key, ref] of snapshot.refs) {
    if (key.startsWith('@') && ref.role.toLowerCase() === role.toLowerCase()) {
      count++
    }
  }
  
  if (typeof expected === 'number') {
    if (count !== expected) {
      throw new AssertionError(
        `Element count mismatch for role "${role}"`,
        count,
        expected
      )
    }
  } else {
    if (expected.min !== undefined && count < expected.min) {
      throw new AssertionError(
        `Too few elements with role "${role}"`,
        count,
        `at least ${expected.min}`
      )
    }
    if (expected.max !== undefined && count > expected.max) {
      throw new AssertionError(
        `Too many elements with role "${role}"`,
        count,
        `at most ${expected.max}`
      )
    }
  }
}

/**
 * Assert no console errors
 */
export function expectNoErrors(events: ConsoleEvent[]): void {
  const errors = events.filter(e => e.type === 'error')
  
  if (errors.length > 0) {
    const messages = errors.map(e => e.text).join('\n')
    throw new AssertionError(
      `Console errors detected:\n${messages}`,
      errors.length,
      0
    )
  }
}

/**
 * Assert console event matches pattern
 */
export function expectConsoleEvent(
  events: ConsoleEvent[],
  pattern: string | RegExp
): void {
  const regex = typeof pattern === 'string' ? new RegExp(pattern, 'i') : pattern
  const found = events.some(e => regex.test(e.text))
  
  if (!found) {
    throw new AssertionError(
      `Console event not found: ${pattern}`,
      'not found',
      pattern.toString()
    )
  }
}

/**
 * Assert element has state
 */
export function expectState(
  snapshot: Snapshot,
  selector: string,
  state: 'disabled' | 'checked' | 'selected' | 'expanded' | 'pressed',
  expected: boolean = true
): void {
  const ref = selector.startsWith('@') 
    ? snapshot.refs.get(selector)
    : findByText(snapshot, selector)
  
  if (!ref) {
    throw new AssertionError(
      `Element not found: ${selector}`,
      'not found',
      state
    )
  }
  
  const actual = ref.state?.[state] ?? false
  
  if (actual !== expected) {
    throw new AssertionError(
      `Element ${selector} state "${state}" mismatch`,
      actual,
      expected
    )
  }
}

/**
 * Assert modal is present/absent
 */
export function expectModal(snapshot: Snapshot, present: boolean = true): void {
  const modals = detectModals(snapshot)
  
  if (present && modals.length === 0) {
    throw new AssertionError(
      'Expected modal to be present',
      'no modal',
      'modal visible'
    )
  }
  
  if (!present && modals.length > 0) {
    throw new AssertionError(
      'Expected no modal to be present',
      `${modals.length} modal(s)`,
      'no modal'
    )
  }
}

/**
 * Assert page title
 */
export function expectTitle(snapshot: Snapshot, title: string, options: { contains?: boolean } = {}): void {
  const actual = snapshot.title
  const matches = options.contains
    ? actual.toLowerCase().includes(title.toLowerCase())
    : actual.toLowerCase() === title.toLowerCase()
  
  if (!matches) {
    throw new AssertionError(
      'Page title mismatch',
      actual,
      title
    )
  }
}

/**
 * Assert element is interactive (clickable)
 */
export function expectClickable(snapshot: Snapshot, selector: string): void {
  const ref = selector.startsWith('@')
    ? snapshot.refs.get(selector)
    : findByText(snapshot, selector)
  
  if (!ref) {
    throw new AssertionError(
      `Element not found: ${selector}`,
      'not found',
      'clickable'
    )
  }
  
  const clickableRoles = ['button', 'link', 'menuitem', 'tab', 'checkbox', 'radio', 'switch']
  
  if (!clickableRoles.includes(ref.role.toLowerCase())) {
    throw new AssertionError(
      `Element ${selector} is not clickable`,
      ref.role,
      'clickable role'
    )
  }
  
  if (ref.state?.disabled) {
    throw new AssertionError(
      `Element ${selector} is disabled`,
      'disabled',
      'enabled'
    )
  }
}

/**
 * Soft assertion (returns result instead of throwing)
 */
export function softExpect<T>(
  fn: () => T
): { ok: true; value: T } | { ok: false; error: Error } {
  try {
    const value = fn()
    return { ok: true, value }
  } catch (error) {
    return { ok: false, error: error instanceof Error ? error : new Error(String(error)) }
  }
}

/**
 * QABot - Main class for web QA automation
 */

import type {
  QABotConfig,
  TestStep,
  TestCase,
  TestSuite,
  TestResult,
  SuiteResult,
  Snapshot,
  StepResult,
  ConsoleEvent
} from './types.js'
import { Browser } from './browser.js'
import { Reporter } from './reporter.js'
import * as assertions from './assertions.js'
import { sleep, retry, waitFor } from './utils/wait.js'
import { resolveRef, detectModals, diffSnapshots } from './utils/snapshot.js'

export class QABot {
  private config: QABotConfig
  private browser: Browser
  private reporter: Reporter
  private currentSnapshot: Snapshot | null = null

  constructor(config: QABotConfig) {
    this.config = {
      timeout: 30000,
      retries: 3,
      waitStrategy: 'auto',
      monitorConsole: true,
      verbose: false,
      ...config
    }

    this.browser = new Browser({
      cdpPort: config.cdpPort,
      headless: config.headless ?? true,
      timeout: this.config.timeout,
      screenshotDir: config.screenshotDir || './screenshots',
      waitStrategy: this.config.waitStrategy,
      verbose: this.config.verbose
    })

    this.reporter = new Reporter()
  }

  /**
   * Navigate to URL
   */
  async goto(url: string): Promise<Snapshot> {
    const fullUrl = url.startsWith('http') ? url : `${this.config.baseUrl}${url}`
    this.currentSnapshot = await this.browser.goto(fullUrl)
    return this.currentSnapshot
  }

  /**
   * Take snapshot
   */
  async snapshot(): Promise<Snapshot> {
    this.currentSnapshot = await this.browser.snapshot()
    return this.currentSnapshot
  }

  /**
   * Take screenshot
   */
  async screenshot(name?: string): Promise<string> {
    return this.browser.screenshot(name)
  }

  /**
   * Click element
   */
  async click(selector: string): Promise<void> {
    const snapshot = this.currentSnapshot || await this.snapshot()
    const ref = resolveRef(snapshot, selector)
    
    if (!ref) {
      throw new Error(`Element not found: ${selector}`)
    }
    
    await this.browser.click(ref)
    
    // Re-snapshot after interaction
    await sleep(100)
    this.currentSnapshot = await this.browser.snapshot()
  }

  /**
   * Type text
   */
  async type(selector: string, text: string): Promise<void> {
    const snapshot = this.currentSnapshot || await this.snapshot()
    const ref = resolveRef(snapshot, selector)
    
    if (!ref) {
      throw new Error(`Element not found: ${selector}`)
    }
    
    await this.browser.type(ref, text)
    this.currentSnapshot = await this.browser.snapshot()
  }

  /**
   * Press key
   */
  async press(key: string): Promise<void> {
    await this.browser.press(key)
    this.currentSnapshot = await this.browser.snapshot()
  }

  /**
   * Hover over element
   */
  async hover(selector: string): Promise<void> {
    const snapshot = this.currentSnapshot || await this.snapshot()
    const ref = resolveRef(snapshot, selector)
    
    if (!ref) {
      throw new Error(`Element not found: ${selector}`)
    }
    
    await this.browser.hover(ref)
  }

  /**
   * Select option
   */
  async select(selector: string, value: string): Promise<void> {
    const snapshot = this.currentSnapshot || await this.snapshot()
    const ref = resolveRef(snapshot, selector)
    
    if (!ref) {
      throw new Error(`Element not found: ${selector}`)
    }
    
    await this.browser.select(ref, value)
    this.currentSnapshot = await this.browser.snapshot()
  }

  /**
   * Wait for element
   */
  async waitFor(selector: string, options?: { timeout?: number }): Promise<Snapshot> {
    this.currentSnapshot = await this.browser.waitFor(selector, options)
    return this.currentSnapshot
  }

  /**
   * Wait for load state
   */
  async waitForLoad(): Promise<void> {
    await sleep(500)
    this.currentSnapshot = await this.browser.snapshot()
  }

  /**
   * Wait for URL
   */
  async waitForUrl(pattern: string | RegExp, options?: { timeout?: number }): Promise<void> {
    await this.browser.waitForUrl(pattern, options)
    this.currentSnapshot = await this.browser.snapshot()
  }

  /**
   * Get console events
   */
  async getConsole(): Promise<ConsoleEvent[]> {
    return this.browser.getConsole()
  }

  /**
   * Expect element visible
   */
  expectVisible(selector: string): void {
    if (!this.currentSnapshot) {
      throw new Error('No snapshot available. Call snapshot() first.')
    }
    assertions.expectVisible(this.currentSnapshot, selector)
  }

  /**
   * Expect element text
   */
  expectText(selector: string, text: string, options?: { contains?: boolean }): void {
    if (!this.currentSnapshot) {
      throw new Error('No snapshot available. Call snapshot() first.')
    }
    assertions.expectText(this.currentSnapshot, selector, text, options)
  }

  /**
   * Expect URL
   */
  expectUrl(expected: string | { contains?: string }): void {
    if (!this.currentSnapshot) {
      throw new Error('No snapshot available. Call snapshot() first.')
    }
    assertions.expectUrl(this.currentSnapshot, expected)
  }

  /**
   * Expect element count
   */
  expectCount(role: string, count: number | { min?: number; max?: number }): void {
    if (!this.currentSnapshot) {
      throw new Error('No snapshot available. Call snapshot() first.')
    }
    assertions.expectCount(this.currentSnapshot, role, count)
  }

  /**
   * Expect no console errors
   */
  async expectNoErrors(): Promise<void> {
    const events = await this.getConsole()
    assertions.expectNoErrors(events)
  }

  /**
   * Expect console event
   */
  async expectConsoleEvent(pattern: string | RegExp): Promise<void> {
    const events = await this.getConsole()
    assertions.expectConsoleEvent(events, pattern)
  }

  /**
   * Expect modal present/absent
   */
  expectModal(present: boolean = true): void {
    if (!this.currentSnapshot) {
      throw new Error('No snapshot available. Call snapshot() first.')
    }
    assertions.expectModal(this.currentSnapshot, present)
  }

  /**
   * Run test steps
   */
  async run(steps: TestStep[]): Promise<StepResult[]> {
    const results: StepResult[] = []

    for (const step of steps) {
      const start = Date.now()
      const stepName = step.name || this.stepToName(step)
      
      try {
        await this.executeStep(step)
        results.push({
          name: stepName,
          status: 'pass',
          duration: Date.now() - start
        })
      } catch (err) {
        const error = err instanceof Error ? err.message : String(err)
        results.push({
          name: stepName,
          status: 'fail',
          duration: Date.now() - start,
          error
        })
        throw err // Stop on first failure
      }
    }

    return results
  }

  /**
   * Execute a single step
   */
  private async executeStep(step: TestStep): Promise<void> {
    if (step.goto) {
      await this.goto(step.goto)
    }
    
    if (step.waitForLoad) {
      await this.waitForLoad()
    }
    
    if (step.waitFor) {
      await this.waitFor(step.waitFor)
    }
    
    if (step.waitMs) {
      await sleep(step.waitMs)
    }
    
    if (step.click) {
      await this.click(step.click)
    }
    
    if (step.type) {
      await this.type(step.type.ref, step.type.text)
    }
    
    if (step.select) {
      await this.select(step.select.ref, step.select.value)
    }
    
    if (step.hover) {
      await this.hover(step.hover)
    }
    
    if (step.press) {
      await this.press(step.press)
    }
    
    if (step.screenshot) {
      await this.screenshot(step.screenshot)
    }
    
    if (step.expectVisible) {
      await this.snapshot()
      this.expectVisible(step.expectVisible)
    }
    
    if (step.expectText) {
      await this.snapshot()
      this.expectText(step.expectText.ref, step.expectText.text, { contains: step.expectText.contains })
    }
    
    if (step.expectUrl) {
      await this.snapshot()
      this.expectUrl(step.expectUrl)
    }
    
    if (step.expectCount) {
      await this.snapshot()
      this.expectCount(step.expectCount.selector, {
        min: step.expectCount.min,
        max: step.expectCount.max
      })
    }
    
    if (step.expectNoErrors) {
      await this.expectNoErrors()
    }
    
    if (step.expectConsoleEvent) {
      await this.expectConsoleEvent(step.expectConsoleEvent)
    }
    
    if (step.assert) {
      const snapshot = await this.snapshot()
      const result = await step.assert(snapshot)
      if (!result) {
        throw new Error('Custom assertion failed')
      }
    }
  }

  /**
   * Convert step to readable name
   */
  private stepToName(step: TestStep): string {
    if (step.goto) return `Navigate to ${step.goto}`
    if (step.click) return `Click ${step.click}`
    if (step.type) return `Type "${step.type.text}" into ${step.type.ref}`
    if (step.select) return `Select "${step.select.value}" in ${step.select.ref}`
    if (step.hover) return `Hover over ${step.hover}`
    if (step.press) return `Press ${step.press}`
    if (step.waitFor) return `Wait for ${step.waitFor}`
    if (step.waitMs) return `Wait ${step.waitMs}ms`
    if (step.screenshot) return `Screenshot: ${step.screenshot}`
    if (step.expectVisible) return `Expect visible: ${step.expectVisible}`
    if (step.expectText) return `Expect text: ${step.expectText.text}`
    if (step.expectUrl) return `Expect URL`
    if (step.expectNoErrors) return `Expect no console errors`
    return 'Unknown step'
  }

  /**
   * Run a test case
   */
  async runTest(test: TestCase): Promise<TestResult> {
    const start = Date.now()
    const screenshots: string[] = []
    let consoleEvents: ConsoleEvent[] = []
    let steps: StepResult[] = []
    let error: string | undefined

    if (test.skip) {
      return {
        name: test.name,
        status: 'skip',
        duration: 0,
        screenshots: [],
        consoleEvents: [],
        steps: []
      }
    }

    try {
      // Clear console before test
      this.browser.clearConsole()
      
      // Run test steps
      steps = await this.run(test.steps)
      
      // Collect console events
      consoleEvents = await this.getConsole()
      
      // Check for console errors if test passed
      const errors = consoleEvents.filter(e => e.type === 'error')
      if (errors.length > 0 && !test.knownIssue) {
        return {
          name: test.name,
          status: 'warn',
          duration: Date.now() - start,
          error: `${errors.length} console error(s)`,
          screenshots,
          consoleEvents,
          knownIssue: test.knownIssue,
          steps
        }
      }

      return {
        name: test.name,
        status: test.knownIssue ? 'warn' : 'pass',
        duration: Date.now() - start,
        screenshots,
        consoleEvents,
        knownIssue: test.knownIssue,
        steps
      }
    } catch (err) {
      error = err instanceof Error ? err.message : String(err)
      
      // Take failure screenshot
      try {
        const screenshotPath = await this.screenshot(`failure-${test.name.replace(/\s+/g, '-')}.png`)
        screenshots.push(screenshotPath)
      } catch {
        // Ignore screenshot errors
      }

      return {
        name: test.name,
        status: test.knownIssue ? 'warn' : 'fail',
        duration: Date.now() - start,
        error,
        screenshots,
        consoleEvents: await this.getConsole(),
        knownIssue: test.knownIssue,
        steps
      }
    }
  }

  /**
   * Run a test suite
   */
  async runSuite(suite: TestSuite): Promise<SuiteResult> {
    const start = Date.now()
    const baseUrl = suite.baseUrl || this.config.baseUrl
    const results: TestResult[] = []

    // Run beforeAll
    if (suite.beforeAll) {
      try {
        await this.run(suite.beforeAll)
      } catch (err) {
        // beforeAll failed, skip all tests
        for (const test of suite.tests) {
          results.push({
            name: test.name,
            status: 'skip',
            duration: 0,
            error: `beforeAll failed: ${err instanceof Error ? err.message : String(err)}`,
            screenshots: [],
            consoleEvents: [],
            steps: []
          })
        }
        
        return this.createSuiteResult(suite.name, baseUrl, results, start)
      }
    }

    // Run tests
    for (const test of suite.tests) {
      // Run beforeEach
      if (suite.beforeEach) {
        try {
          await this.run(suite.beforeEach)
        } catch (err) {
          results.push({
            name: test.name,
            status: 'skip',
            duration: 0,
            error: `beforeEach failed: ${err instanceof Error ? err.message : String(err)}`,
            screenshots: [],
            consoleEvents: [],
            steps: []
          })
          continue
        }
      }

      // Run test
      const result = await this.runTest(test)
      results.push(result)

      // Run afterEach
      if (suite.afterEach) {
        try {
          await this.run(suite.afterEach)
        } catch {
          // Ignore afterEach errors
        }
      }
    }

    // Run afterAll
    if (suite.afterAll) {
      try {
        await this.run(suite.afterAll)
      } catch {
        // Ignore afterAll errors
      }
    }

    const suiteResult = this.createSuiteResult(suite.name, baseUrl, results, start)
    this.reporter.addResult(suiteResult)
    
    return suiteResult
  }

  /**
   * Create suite result object
   */
  private createSuiteResult(
    name: string,
    url: string,
    tests: TestResult[],
    startTime: number
  ): SuiteResult {
    const summary = {
      total: tests.length,
      passed: tests.filter(t => t.status === 'pass').length,
      failed: tests.filter(t => t.status === 'fail').length,
      skipped: tests.filter(t => t.status === 'skip').length,
      warnings: tests.filter(t => t.status === 'warn').length
    }

    return {
      name,
      url,
      tests,
      duration: Date.now() - startTime,
      summary,
      timestamp: Date.now()
    }
  }

  /**
   * Generate report
   */
  async generateReport(output: string, options: { format?: 'markdown' | 'pdf' | 'json'; company?: string } = {}): Promise<string> {
    return this.reporter.generate({
      output,
      format: options.format,
      company: options.company,
      includeScreenshots: true
    })
  }

  /**
   * Get reporter
   */
  getReporter(): Reporter {
    return this.reporter
  }

  /**
   * Close browser
   */
  async close(): Promise<void> {
    await this.browser.close()
  }

  /**
   * Get browser instance
   */
  getBrowser(): Browser {
    return this.browser
  }

  /**
   * Get current snapshot
   */
  getCurrentSnapshot(): Snapshot | null {
    return this.currentSnapshot
  }
}

/**
 * Browser automation wrapper for agent-browser CLI
 */

import { spawn, execSync } from 'node:child_process'
import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs'
import { join } from 'node:path'
import type { Snapshot, ConsoleEvent, WaitStrategy } from './types.js'
import { parseSnapshot } from './utils/snapshot.js'
import { ConsoleMonitor } from './utils/console.js'
import { sleep, retry, waitStrategyToArgs } from './utils/wait.js'

export interface BrowserOptions {
  cdpPort?: number
  headless?: boolean
  timeout?: number
  screenshotDir?: string
  waitStrategy?: WaitStrategy
  verbose?: boolean
}

export class Browser {
  private cdpPort: number
  private headless: boolean
  private timeout: number
  private screenshotDir: string
  private waitStrategy: WaitStrategy
  private verbose: boolean
  private consoleMonitor: ConsoleMonitor
  private currentUrl: string = ''
  private launched: boolean = false

  constructor(options: BrowserOptions = {}) {
    this.cdpPort = options.cdpPort || 0 // 0 = auto-assign
    this.headless = options.headless ?? true
    this.timeout = options.timeout || 30000
    this.screenshotDir = options.screenshotDir || './screenshots'
    this.waitStrategy = options.waitStrategy || 'auto'
    this.verbose = options.verbose || false
    this.consoleMonitor = new ConsoleMonitor()
  }

  /**
   * Execute agent-browser command
   */
  private exec(args: string[], timeout?: number): string {
    const cdpArgs = this.cdpPort ? ['--cdp', String(this.cdpPort)] : []
    const cmd = ['agent-browser', ...cdpArgs, ...args].join(' ')
    
    if (this.verbose) {
      console.log(`[browser] ${cmd}`)
    }
    
    try {
      const result = execSync(cmd, {
        encoding: 'utf-8',
        timeout: timeout || this.timeout,
        stdio: ['pipe', 'pipe', 'pipe']
      })
      return result.trim()
    } catch (err: any) {
      const stderr = err.stderr?.toString() || ''
      const stdout = err.stdout?.toString() || ''
      throw new Error(`Browser command failed: ${cmd}\n${stderr || stdout}`)
    }
  }

  /**
   * Launch browser if not connected
   */
  async launch(): Promise<void> {
    if (this.launched || this.cdpPort) {
      return
    }

    // Check if agent-browser is installed
    try {
      execSync('which agent-browser', { stdio: 'pipe' })
    } catch {
      throw new Error(
        'agent-browser CLI not found. Install it with: npm install -g agent-browser'
      )
    }

    // Launch browser and get CDP port
    const args = this.headless ? ['--headless'] : []
    const output = this.exec(['launch', ...args])
    
    // Parse CDP port from output
    const portMatch = output.match(/CDP port[:\s]+(\d+)/i)
    if (portMatch) {
      this.cdpPort = parseInt(portMatch[1], 10)
    } else {
      // Default port if not found
      this.cdpPort = 9222
    }
    
    this.launched = true
    await sleep(1000) // Wait for browser to fully start
  }

  /**
   * Connect to existing browser
   */
  connect(cdpPort: number): void {
    this.cdpPort = cdpPort
  }

  /**
   * Navigate to URL
   */
  async goto(url: string): Promise<Snapshot> {
    await this.launch()
    
    const waitArgs = waitStrategyToArgs(this.waitStrategy)
    this.exec(['navigate', url, ...waitArgs])
    this.currentUrl = url
    
    // Take snapshot after navigation
    return this.snapshot()
  }

  /**
   * Take accessibility tree snapshot
   */
  async snapshot(): Promise<Snapshot> {
    await this.launch()
    
    const output = await retry(() => Promise.resolve(this.exec(['snapshot'])))
    return parseSnapshot(output, this.currentUrl)
  }

  /**
   * Take screenshot
   */
  async screenshot(name?: string): Promise<string> {
    await this.launch()
    
    // Ensure screenshot directory exists
    if (!existsSync(this.screenshotDir)) {
      mkdirSync(this.screenshotDir, { recursive: true })
    }
    
    const filename = name || `screenshot-${Date.now()}.png`
    const filepath = join(this.screenshotDir, filename)
    
    this.exec(['screenshot', filepath])
    return filepath
  }

  /**
   * Click element by ref
   */
  async click(ref: string): Promise<void> {
    await this.launch()
    
    await retry(() => {
      this.exec(['click', ref])
      return Promise.resolve()
    })
    
    // Brief wait for UI to update
    await sleep(100)
  }

  /**
   * Type text into element
   */
  async type(ref: string, text: string): Promise<void> {
    await this.launch()
    
    // Click to focus first
    await this.click(ref)
    
    // Type text
    this.exec(['type', `"${text.replace(/"/g, '\\"')}"`])
  }

  /**
   * Press key
   */
  async press(key: string): Promise<void> {
    await this.launch()
    this.exec(['press', key])
  }

  /**
   * Hover over element
   */
  async hover(ref: string): Promise<void> {
    await this.launch()
    this.exec(['hover', ref])
  }

  /**
   * Select option from dropdown
   */
  async select(ref: string, value: string): Promise<void> {
    await this.launch()
    await this.click(ref)
    await sleep(200)
    
    // Take snapshot to find option
    const snapshot = await this.snapshot()
    
    // Look for option with matching text
    for (const [key, elem] of snapshot.refs) {
      if (key.startsWith('@') && elem.name.toLowerCase().includes(value.toLowerCase())) {
        if (elem.role === 'option' || elem.role === 'menuitem' || elem.role === 'listitem') {
          await this.click(elem.id)
          return
        }
      }
    }
    
    throw new Error(`Option "${value}" not found in dropdown`)
  }

  /**
   * Wait for element to appear
   */
  async waitFor(selector: string, options: { timeout?: number } = {}): Promise<Snapshot> {
    const timeout = options.timeout || this.timeout
    const start = Date.now()
    
    while (Date.now() - start < timeout) {
      const snapshot = await this.snapshot()
      
      // Check if element exists
      if (selector.startsWith('@')) {
        if (snapshot.refs.has(selector)) {
          return snapshot
        }
      } else {
        // Search by text/role
        for (const [, ref] of snapshot.refs) {
          if (ref.name.toLowerCase().includes(selector.toLowerCase())) {
            return snapshot
          }
        }
      }
      
      await sleep(200)
    }
    
    throw new Error(`Timeout waiting for element: ${selector}`)
  }

  /**
   * Wait for URL to match
   */
  async waitForUrl(pattern: string | RegExp, options: { timeout?: number } = {}): Promise<void> {
    const timeout = options.timeout || this.timeout
    const start = Date.now()
    
    while (Date.now() - start < timeout) {
      const snapshot = await this.snapshot()
      const url = snapshot.url
      
      if (typeof pattern === 'string') {
        if (url.includes(pattern)) return
      } else {
        if (pattern.test(url)) return
      }
      
      await sleep(200)
    }
    
    throw new Error(`Timeout waiting for URL: ${pattern}`)
  }

  /**
   * Get console events
   */
  async getConsole(): Promise<ConsoleEvent[]> {
    await this.launch()
    
    try {
      const output = this.exec(['console'])
      const events = this.consoleMonitor.parseAgentBrowserConsole(output)
      
      for (const event of events) {
        this.consoleMonitor.addEvent(event)
      }
      
      return this.consoleMonitor.getEvents()
    } catch {
      return []
    }
  }

  /**
   * Get console monitor
   */
  getConsoleMonitor(): ConsoleMonitor {
    return this.consoleMonitor
  }

  /**
   * Clear console events
   */
  clearConsole(): void {
    this.consoleMonitor.clear()
  }

  /**
   * Close browser
   */
  async close(): Promise<void> {
    if (this.launched) {
      try {
        this.exec(['close'])
      } catch {
        // Ignore close errors
      }
      this.launched = false
    }
  }

  /**
   * Get current URL
   */
  getUrl(): string {
    return this.currentUrl
  }

  /**
   * Check if connected
   */
  isConnected(): boolean {
    return this.launched || this.cdpPort > 0
  }

  /**
   * Evaluate JavaScript in page
   */
  async evaluate<T>(script: string): Promise<T> {
    await this.launch()
    const output = this.exec(['evaluate', `"${script.replace(/"/g, '\\"')}"`])
    
    try {
      return JSON.parse(output) as T
    } catch {
      return output as unknown as T
    }
  }
}

#!/usr/bin/env node

/**
 * web-qa-bot CLI
 */

import { parseArgs } from 'node:util'
import { readFileSync, existsSync } from 'node:fs'
import { resolve, extname } from 'node:path'
import { parse as parseYaml } from 'yaml'
import { QABot } from './bot.js'
import { smokeTest } from './smoke.js'
import { generateReportFromFile } from './reporter.js'
import type { TestSuite, SmokeCheck } from './types.js'

const VERSION = '0.1.0'

const HELP = `
web-qa-bot v${VERSION}
AI-powered web application QA automation

USAGE:
  web-qa-bot <command> [options]

COMMANDS:
  smoke <url>              Run smoke tests on a URL
  run <suite>              Run test suite from file
  report <results>         Generate report from results

OPTIONS:
  -o, --output <path>      Output file path
  -f, --format <format>    Report format: markdown, pdf, json
  --cdp <port>             Connect to existing browser CDP port
  --headless               Run in headless mode (default: true)
  --no-headless            Run in headed mode
  --timeout <ms>           Default timeout in milliseconds
  --verbose                Enable verbose logging
  -h, --help               Show this help
  -v, --version            Show version

EXAMPLES:
  # Quick smoke test
  web-qa-bot smoke https://example.com

  # Run test suite
  web-qa-bot run ./tests/suite.yaml --output results.json

  # Generate PDF report
  web-qa-bot report ./results.json -o report.pdf -f pdf

  # Connect to existing browser
  web-qa-bot smoke https://example.com --cdp 9222
`

async function main() {
  const { values, positionals } = parseArgs({
    allowPositionals: true,
    options: {
      output: { type: 'string', short: 'o' },
      format: { type: 'string', short: 'f' },
      cdp: { type: 'string' },
      headless: { type: 'boolean', default: true },
      'no-headless': { type: 'boolean' },
      timeout: { type: 'string' },
      verbose: { type: 'boolean' },
      help: { type: 'boolean', short: 'h' },
      version: { type: 'boolean', short: 'v' },
      checks: { type: 'string' },
      company: { type: 'string' }
    }
  })

  if (values.help || positionals.length === 0) {
    console.log(HELP)
    process.exit(0)
  }

  if (values.version) {
    console.log(VERSION)
    process.exit(0)
  }

  const command = positionals[0]
  const target = positionals[1]

  try {
    switch (command) {
      case 'smoke':
        await runSmoke(target, values)
        break
      case 'run':
        await runSuite(target, values)
        break
      case 'report':
        await generateReport(target, values)
        break
      default:
        console.error(`Unknown command: ${command}`)
        console.log(HELP)
        process.exit(1)
    }
  } catch (err) {
    console.error('Error:', err instanceof Error ? err.message : err)
    if (values.verbose) {
      console.error(err)
    }
    process.exit(1)
  }
}

async function runSmoke(url: string, options: Record<string, any>) {
  if (!url) {
    throw new Error('URL required for smoke test')
  }

  console.log(`Running smoke test on ${url}...`)

  const checks = options.checks
    ? options.checks.split(',').map((c: string) => c.trim() as SmokeCheck)
    : undefined

  const result = await smokeTest({
    url,
    checks,
    timeout: options.timeout ? parseInt(options.timeout, 10) : undefined,
    report: !!options.output,
    output: options.output
  })

  // Print summary
  console.log('\n=== Smoke Test Results ===\n')
  console.log(`URL: ${result.url}`)
  console.log(`Duration: ${(result.duration / 1000).toFixed(2)}s`)
  console.log()

  for (const test of result.tests) {
    const icon = test.status === 'pass' ? '✓' : test.status === 'fail' ? '✗' : '○'
    const status = test.status.toUpperCase()
    console.log(`${icon} ${test.name}: ${status}`)
    if (test.error) {
      console.log(`  → ${test.error}`)
    }
  }

  console.log()
  console.log(`Total: ${result.summary.total} | Pass: ${result.summary.passed} | Fail: ${result.summary.failed} | Warn: ${result.summary.warnings}`)

  if (options.output) {
    console.log(`\nReport saved to: ${options.output}`)
  }

  // Exit with error if any tests failed
  if (result.summary.failed > 0) {
    process.exit(1)
  }
}

async function runSuite(suitePath: string, options: Record<string, any>) {
  if (!suitePath) {
    throw new Error('Suite file path required')
  }

  const fullPath = resolve(suitePath)
  if (!existsSync(fullPath)) {
    throw new Error(`Suite file not found: ${fullPath}`)
  }

  console.log(`Running test suite: ${suitePath}`)

  // Load suite file
  const content = readFileSync(fullPath, 'utf-8')
  const ext = extname(fullPath).toLowerCase()
  
  let suite: TestSuite
  if (ext === '.yaml' || ext === '.yml') {
    suite = parseYaml(content) as TestSuite
  } else if (ext === '.json') {
    suite = JSON.parse(content) as TestSuite
  } else {
    throw new Error(`Unsupported file format: ${ext}`)
  }

  // Create QA bot
  const qa = new QABot({
    baseUrl: suite.baseUrl || 'http://localhost',
    cdpPort: options.cdp ? parseInt(options.cdp, 10) : undefined,
    headless: !options['no-headless'],
    timeout: options.timeout ? parseInt(options.timeout, 10) : undefined,
    verbose: options.verbose
  })

  try {
    const result = await qa.runSuite(suite)

    // Print results
    console.log('\n=== Test Results ===\n')
    console.log(`Suite: ${result.name}`)
    console.log(`Duration: ${(result.duration / 1000).toFixed(2)}s`)
    console.log()

    for (const test of result.tests) {
      const icon = test.status === 'pass' ? '✓' : test.status === 'fail' ? '✗' : test.status === 'warn' ? '⚠' : '○'
      console.log(`${icon} ${test.name}`)
      if (test.error) {
        console.log(`  → ${test.error}`)
      }
    }

    console.log()
    console.log(`Total: ${result.summary.total} | Pass: ${result.summary.passed} | Fail: ${result.summary.failed} | Warn: ${result.summary.warnings}`)

    // Generate report if requested
    if (options.output) {
      const format = options.format || (options.output.endsWith('.pdf') ? 'pdf' : 'markdown')
      await qa.generateReport(options.output, { format, company: options.company })
      console.log(`\nReport saved to: ${options.output}`)
    }

    if (result.summary.failed > 0) {
      process.exit(1)
    }
  } finally {
    await qa.close()
  }
}

async function generateReport(resultsPath: string, options: Record<string, any>) {
  if (!resultsPath) {
    throw new Error('Results file path required')
  }

  const output = options.output || resultsPath.replace(/\.json$/, '.md')
  const format = options.format || (output.endsWith('.pdf') ? 'pdf' : output.endsWith('.json') ? 'json' : 'markdown')

  console.log(`Generating ${format} report...`)

  const reportPath = await generateReportFromFile(resultsPath, {
    output,
    format: format as any,
    company: options.company,
    includeScreenshots: true
  })

  console.log(`Report saved to: ${reportPath}`)
}

main().catch(err => {
  console.error('Fatal error:', err)
  process.exit(1)
})