Windows Desktop Automation

# Python
.venv/
__pycache__/
*.pyc
*.pyo
*.pyd

# Node
node_modules/

# .NET
bin/
obj/

# OS / tooling
.DS_Store
Thumbs.db

# Logs
*.log

# Embedded Python (should not be committed)
src/python-embedded/

# Misc
.vscode/

# Weird Windows reserved name that shouldn't exist as a file
nul

# Auto-Setup Script for Windows Automation Skill
# Downloads and configures EVERYTHING automatically.

$ErrorActionPreference = "Stop"
$ProgressPreference = "SilentlyContinue"

Write-Host ">>> Iniciando Auto-Setup Windows Automation Skill (system Python) <<<" -ForegroundColor Cyan

# 0. Definir rutas
$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
$skillRoot = Resolve-Path (Join-Path $scriptDir "..") # skill root
$javaLibDir = Join-Path $skillRoot "src\bridge_java\lib"
$modelsDir = Join-Path $skillRoot "src\bridge_python\models"
$sikuliUrl = "https://launchpad.net/sikuli/sikulix/2.0.5/+download/sikulixapi-2.0.5.jar"
$omniparserUrl = "https://huggingface.co/microsoft/OmniParser/resolve/main/icon_detect/model.onnx"

# 1. Verificar Python (system installed)
Write-Host "[1/4] Verificando Python instalado en el sistema..." -ForegroundColor Yellow

$PythonExe = $null
if (Get-Command py -ErrorAction SilentlyContinue) {
    $PythonExe = "py"
} elseif (Get-Command python -ErrorAction SilentlyContinue) {
    $PythonExe = "python"
}

if (-not $PythonExe) {
    Write-Host "[ERROR] Python no encontrado. Instala Python 3.11+ y asegfarate de tener 'py' o 'python' en PATH." -ForegroundColor Red
    throw "Python missing"
}

Write-Host "[OK] Python detectado: $PythonExe" -ForegroundColor Green

# 2. Crear venv local (recomendado)
Write-Host "[2/4] Creando entorno virtual (.venv)..." -ForegroundColor Yellow
$venvDir = Join-Path $skillRoot ".venv"
if (-not (Test-Path $venvDir)) {
    if ($PythonExe -eq "py") {
        & py -3 -m venv $venvDir
    } else {
        & python -m venv $venvDir
    }
} else {
    Write-Host "[SKIP] .venv ya existe." -ForegroundColor Gray
}

$VenvPython = Join-Path $venvDir "Scripts\python.exe"
if (-not (Test-Path $VenvPython)) {
    throw "No se pudo crear .venv (faltfa $VenvPython)"
}

# 3. Instalar dependencias Python
Write-Host "[3/4] Instalando dependencias Python (Flask, pywinauto, etc.)..." -ForegroundColor Yellow
try {
    & $VenvPython -m pip install --upgrade pip --quiet
    & $VenvPython -m pip install flask pywinauto comtypes onnxruntime numpy Pillow --quiet
    Write-Host "[OK] Dependencias Python instaladas." -ForegroundColor Green
} catch {
    Write-Host "[WARN] No se pudieron instalar dependencias Python: $_" -ForegroundColor Yellow
}

# 4. Instalar Vision Layer Dependencies (OmniParser is optional)
Write-Host "[4/4] Vision Layer: dependencias listas (modelo OmniParser opcional)." -ForegroundColor Yellow

# 3. Descargar OmniParser Model
if (-not (Test-Path $modelsDir)) {
    New-Item -ItemType Directory -Force -Path $modelsDir | Out-Null
}
$omniparserPath = Join-Path $modelsDir "omniparser-icon_detect.onnx"
if (-not (Test-Path $omniparserPath)) {
    Write-Host "[3/5] Descargando OmniParser model (~6MB)..." -ForegroundColor Yellow
    try {
        $webClient = New-Object System.Net.WebClient
        $webClient.DownloadFile($omniparserUrl, $omniparserPath)
        $fileSize = (Get-Item $omniparserPath).Length / 1MB
        Write-Host "[OK] OmniParser descargado ($([math]::Round($fileSize, 2)) MB)." -ForegroundColor Green
    } catch {
        Write-Host "[WARN] Falló descarga de OmniParser. La Vision Layer estará deshabilitada." -ForegroundColor Yellow
        Write-Host "       Descarga manual: $omniparserUrl" -ForegroundColor Gray
    }
} else {
    Write-Host "[SKIP] OmniParser ya existe." -ForegroundColor Gray
}

# 4. Configurar SikuliX
if (-not (Test-Path $javaLibDir)) {
    New-Item -ItemType Directory -Force -Path $javaLibDir | Out-Null
}
$sikuliJar = Join-Path $javaLibDir "sikulixapi.jar"
if (-not (Test-Path $sikuliJar)) {
    Write-Host "[4/5] Descargando SikuliX API JAR..." -ForegroundColor Yellow
    # SikuliX launchpad redirects can be tricky, using direct link logic or fallback
    # Using a known reliable direct link structure or user prompt if fails.
    # Trying direct download:
    try {
        Invoke-WebRequest -Uri $sikuliUrl -OutFile $sikuliJar
        Write-Host "[OK] SikuliX descargado." -ForegroundColor Green
    } catch {
        Write-Host "[ERROR] Falló descarga automática de SikuliX. Por favor descarga $sikuliUrl manualmente a $javaLibDir" -ForegroundColor Red
    }
} else {
    Write-Host "[SKIP] SikuliX ya existe." -ForegroundColor Gray
}

# 5. Compilar .NET Project
Write-Host "[5/5] Compilando MainAgentService (.NET)..." -ForegroundColor Yellow
$projPath = Join-Path $skillRoot "src\src\MainAgentService\MainAgentService.csproj"
dotnet build $projPath
if ($LASTEXITCODE -eq 0) {
    Write-Host "[OK] Compilación exitosa." -ForegroundColor Green
} else {
    Write-Host "[ERROR] Falló la compilación." -ForegroundColor Red
}

Write-Host "`n>>> Instalación v4.0 COMPLETADA <<<" -ForegroundColor Cyan
Write-Host "Componentes instalados/configurados:" -ForegroundColor White
Write-Host "  - Python del sistema + .venv" -ForegroundColor Gray
Write-Host "  - Dependencias Python (Flask, pywinauto, ONNX Runtime, etc.)" -ForegroundColor Gray
Write-Host "  - OmniParser ONNX model (~6MB, opcional)" -ForegroundColor Gray
Write-Host "  - SikuliX API JAR (si aplica)" -ForegroundColor Gray
Write-Host "  - MainAgentService (.NET 9)" -ForegroundColor Gray
Write-Host "`nAhora ejecuta: .\scripts\start-all.ps1" -ForegroundColor White

# Download OmniParser Model Script
# Downloads the OmniParser icon detection ONNX model for the Vision Layer

$ErrorActionPreference = "Stop"
$ProgressPreference = "SilentlyContinue"

Write-Host ">>> OmniParser Model Download <<<" -ForegroundColor Cyan

# Define paths
$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
$skillRoot = Resolve-Path (Join-Path $scriptDir "..")
$modelsDir = Join-Path $skillRoot "src\bridge_python\models"
$modelPath = Join-Path $modelsDir "omniparser-icon_detect.onnx"

# Model URL (Microsoft OmniParser from HuggingFace)
$modelUrl = "https://huggingface.co/microsoft/OmniParser/resolve/main/icon_detect/model.onnx"

# Create models directory if needed
if (-not (Test-Path $modelsDir)) {
    Write-Host "[INFO] Creating models directory..." -ForegroundColor Yellow
    New-Item -ItemType Directory -Force -Path $modelsDir | Out-Null
}

# Download model
if (-not (Test-Path $modelPath)) {
    Write-Host "[1/1] Downloading OmniParser model (~6MB)..." -ForegroundColor Yellow
    Write-Host "      URL: $modelUrl" -ForegroundColor Gray
    Write-Host "      Destination: $modelPath" -ForegroundColor Gray
    
    try {
        # Use Invoke-WebRequest with longer timeout for HuggingFace
        $webClient = New-Object System.Net.WebClient
        $webClient.DownloadFile($modelUrl, $modelPath)
        
        # Verify file size (should be ~6MB)
        $fileSize = (Get-Item $modelPath).Length / 1MB
        if ($fileSize -lt 1) {
            throw "Downloaded file is too small ($fileSize MB). Expected ~6MB."
        }
        
        Write-Host "[OK] OmniParser model downloaded successfully ($([math]::Round($fileSize, 2)) MB)" -ForegroundColor Green
    } catch {
        Write-Host "[ERROR] Failed to download OmniParser model: $_" -ForegroundColor Red
        Write-Host "[INFO] Please download manually from:" -ForegroundColor Yellow
        Write-Host "       $modelUrl" -ForegroundColor White
        Write-Host "       Save to: $modelPath" -ForegroundColor White
        exit 1
    }
} else {
    $fileSize = (Get-Item $modelPath).Length / 1MB
    Write-Host "[SKIP] OmniParser model already exists ($([math]::Round($fileSize, 2)) MB)" -ForegroundColor Gray
}

Write-Host "`n>>> OmniParser Download Complete <<<" -ForegroundColor Cyan

#!/usr/bin/env node
/**
 * get-command-help.cjs - Lazy-load command documentation
 * 
 * Query command schemas, examples, and tips from command-schemas.json
 * without loading the entire documentation into context.
 * 
 * Usage:
 *   node scripts/get-command-help.cjs <command>           # Full details for a command
 *   node scripts/get-command-help.cjs --list              # List all commands
 *   node scripts/get-command-help.cjs --category <name>   # Commands in a category
 *   node scripts/get-command-help.cjs --schema <command>  # Just the JSON schema
 *   node scripts/get-command-help.cjs --example <command> # Just the example
 *   node scripts/get-command-help.cjs --errors            # List all error codes
 *   node scripts/get-command-help.cjs --categories        # List all categories
 *   node scripts/get-command-help.cjs --search <term>     # Search commands by keyword
 */

const fs = require('fs');
const path = require('path');

// Load schemas
const schemasPath = path.join(__dirname, '..', 'docs', 'command-schemas.json');
let schemas;

try {
  schemas = JSON.parse(fs.readFileSync(schemasPath, 'utf8'));
} catch (e) {
  console.error(`Error loading schemas: ${e.message}`);
  console.error(`Expected file at: ${schemasPath}`);
  process.exit(1);
}

// Parse arguments
const args = process.argv.slice(2);

if (args.length === 0) {
  printUsage();
  process.exit(0);
}

// Handle flags
const flag = args[0];

switch (flag) {
  case '--help':
  case '-h':
    printUsage();
    break;
    
  case '--list':
  case '-l':
    listAllCommands();
    break;
    
  case '--categories':
  case '-c':
    listCategories();
    break;
    
  case '--category':
    if (!args[1]) {
      console.error('Error: --category requires a category name');
      console.error('Use --categories to see available categories');
      process.exit(1);
    }
    showCategory(args[1]);
    break;
    
  case '--schema':
  case '-s':
    if (!args[1]) {
      console.error('Error: --schema requires a command name');
      process.exit(1);
    }
    showSchema(args[1]);
    break;
    
  case '--example':
  case '-e':
    if (!args[1]) {
      console.error('Error: --example requires a command name');
      process.exit(1);
    }
    showExample(args[1]);
    break;
    
  case '--errors':
    listErrors();
    break;
    
  case '--search':
    if (!args[1]) {
      console.error('Error: --search requires a search term');
      process.exit(1);
    }
    searchCommands(args[1]);
    break;
    
  default:
    // Assume it's a command name
    if (flag.startsWith('-')) {
      console.error(`Unknown flag: ${flag}`);
      printUsage();
      process.exit(1);
    }
    showCommandDetails(flag);
}

// === Functions ===

function printUsage() {
  console.log(`
Windows Desktop Automation - Command Help (v${schemas.version})
${'='.repeat(50)}

Usage:
  node get-command-help.cjs <command>           Full details for a command
  node get-command-help.cjs --list              List all commands
  node get-command-help.cjs --categories        List all categories
  node get-command-help.cjs --category <name>   Commands in a category
  node get-command-help.cjs --schema <command>  Just the JSON schema
  node get-command-help.cjs --example <command> Just the example
  node get-command-help.cjs --errors            List all error codes
  node get-command-help.cjs --search <term>     Search commands by keyword

Examples:
  node get-command-help.cjs click
  node get-command-help.cjs --category mouse
  node get-command-help.cjs --schema explore_window
  node get-command-help.cjs --search window
`);
}

function listAllCommands() {
  console.log(`\nAll Commands (${Object.keys(schemas.commands).length} total):`);
  console.log('='.repeat(60));
  
  // Group by category
  for (const [catId, cat] of Object.entries(schemas.categories)) {
    console.log(`\n${cat.name}:`);
    for (const cmd of cat.commands) {
      const cmdData = schemas.commands[cmd];
      const desc = cmdData ? cmdData.description.substring(0, 50) : 'N/A';
      console.log(`  ${cmd.padEnd(20)} ${desc}...`);
    }
  }
}

function listCategories() {
  console.log('\nAvailable Categories:');
  console.log('='.repeat(40));
  
  for (const [catId, cat] of Object.entries(schemas.categories)) {
    console.log(`\n${catId.padEnd(18)} ${cat.name}`);
    console.log(`${''.padEnd(18)} ${cat.description}`);
    console.log(`${''.padEnd(18)} Commands: ${cat.commands.length}`);
  }
}

function showCategory(categoryName) {
  const catId = categoryName.toLowerCase().replace(/\s+/g, '_');
  const cat = schemas.categories[catId];
  
  if (!cat) {
    console.error(`Category not found: ${categoryName}`);
    console.error('\nAvailable categories:');
    for (const id of Object.keys(schemas.categories)) {
      console.error(`  - ${id}`);
    }
    process.exit(1);
  }
  
  console.log(`\n${cat.name} Commands`);
  console.log('='.repeat(50));
  console.log(`${cat.description}\n`);
  
  for (const cmdName of cat.commands) {
    const cmd = schemas.commands[cmdName];
    if (cmd) {
      console.log(`${cmdName}`);
      console.log(`  ${cmd.description}`);
      console.log(`  Required: ${cmd.required.join(', ') || 'none'}`);
      console.log(`  Optional: ${cmd.optional.join(', ') || 'none'}`);
      console.log();
    }
  }
}

function showSchema(commandName) {
  const cmd = schemas.commands[commandName];
  
  if (!cmd) {
    console.error(`Command not found: ${commandName}`);
    suggestSimilar(commandName);
    process.exit(1);
  }
  
  console.log(`\nSchema for: ${commandName}`);
  console.log('='.repeat(40));
  console.log(JSON.stringify(cmd.schema, null, 2));
  console.log(`\nRequired: ${cmd.required.join(', ')}`);
  console.log(`Optional: ${cmd.optional.join(', ') || 'none'}`);
}

function showExample(commandName) {
  const cmd = schemas.commands[commandName];
  
  if (!cmd) {
    console.error(`Command not found: ${commandName}`);
    suggestSimilar(commandName);
    process.exit(1);
  }
  
  console.log(`\nExample for: ${commandName}`);
  console.log('='.repeat(40));
  console.log(JSON.stringify(cmd.example, null, 2));
}

function showCommandDetails(commandName) {
  const cmd = schemas.commands[commandName];
  
  if (!cmd) {
    console.error(`Command not found: ${commandName}`);
    suggestSimilar(commandName);
    process.exit(1);
  }
  
  console.log(`
${'='.repeat(60)}
Command: ${commandName}
Category: ${cmd.category}
${'='.repeat(60)}

${cmd.description}

REQUIRED PARAMETERS:
${formatParameters(cmd.schema, cmd.required)}

OPTIONAL PARAMETERS:
${cmd.optional.length > 0 ? formatParameters(cmd.schema, cmd.optional) : '  (none)'}

EXAMPLE:
${JSON.stringify(cmd.example, null, 2)}

RETURNS:
${JSON.stringify(cmd.returns, null, 2)}

TIPS:
${cmd.tips ? cmd.tips.map(t => `  - ${t}`).join('\n') : '  (none)'}
`);
}

function formatParameters(schema, params) {
  if (!params || params.length === 0) return '  (none)';
  
  return params.map(p => {
    const paramSchema = schema[p];
    if (!paramSchema) return `  - ${p}`;
    
    const type = paramSchema.type || 'any';
    const desc = paramSchema.description || '';
    const def = paramSchema.default !== undefined ? ` (default: ${paramSchema.default})` : '';
    const constVal = paramSchema.const ? ` = "${paramSchema.const}"` : '';
    
    return `  - ${p} (${type})${constVal}: ${desc}${def}`;
  }).join('\n');
}

function listErrors() {
  console.log('\nError Codes:');
  console.log('='.repeat(60));
  
  for (const [code, info] of Object.entries(schemas.error_codes)) {
    console.log(`\n${code}`);
    console.log(`  Meaning:  ${info.meaning}`);
    console.log(`  Recovery: ${info.recovery}`);
  }
}

function searchCommands(term) {
  const searchTerm = term.toLowerCase();
  const matches = [];
  
  for (const [name, cmd] of Object.entries(schemas.commands)) {
    const searchableText = `${name} ${cmd.description} ${cmd.category}`.toLowerCase();
    if (searchableText.includes(searchTerm)) {
      matches.push({ name, cmd });
    }
  }
  
  if (matches.length === 0) {
    console.log(`\nNo commands found matching: "${term}"`);
    return;
  }
  
  console.log(`\nCommands matching "${term}" (${matches.length} found):`);
  console.log('='.repeat(50));
  
  for (const { name, cmd } of matches) {
    console.log(`\n${name} [${cmd.category}]`);
    console.log(`  ${cmd.description}`);
  }
}

function suggestSimilar(commandName) {
  const allCommands = Object.keys(schemas.commands);
  const similar = allCommands.filter(cmd => 
    cmd.includes(commandName) || 
    commandName.includes(cmd) ||
    levenshteinDistance(cmd, commandName) <= 3
  );
  
  if (similar.length > 0) {
    console.error('\nDid you mean:');
    for (const s of similar.slice(0, 5)) {
      console.error(`  - ${s}`);
    }
  }
}

function levenshteinDistance(a, b) {
  const matrix = Array(b.length + 1).fill(null).map(() => Array(a.length + 1).fill(null));
  
  for (let i = 0; i <= a.length; i++) matrix[0][i] = i;
  for (let j = 0; j <= b.length; j++) matrix[j][0] = j;
  
  for (let j = 1; j <= b.length; j++) {
    for (let i = 1; i <= a.length; i++) {
      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
      matrix[j][i] = Math.min(
        matrix[j][i - 1] + 1,
        matrix[j - 1][i] + 1,
        matrix[j - 1][i - 1] + cost
      );
    }
  }
  
  return matrix[b.length][a.length];
}

// windows-desktop-automation helper
// Usage:
//   node scripts/send-command.cjs '{"action":"explore"}'
//   echo '{"action":"explore"}' | node scripts/send-command.cjs
//
// This script communicates with MainAgentService HTTP server and sends one JSON command.
// If server is not running, it starts it automatically.

const http = require('http');
const { spawn } = require('child_process');
const path = require('path');

// Resolve agent path relative to this script (using Release build)
const AGENT_PATH = path.resolve(__dirname, '..', 'src', 'src', 'MainAgentService', 'bin', 'Release', 'net9.0-windows', 'MainAgentService.exe');

function readStdin() {
  return new Promise((resolve) => {
    let data = '';
    process.stdin.setEncoding('utf8');
    process.stdin.on('data', (chunk) => (data += chunk));
    process.stdin.on('end', () => resolve(data.trim()));
    if (process.stdin.isTTY) resolve(null);
  });
}

// Function to check if service is running
function isServiceRunning() {
  return new Promise((resolve) => {
    const req = http.get('http://localhost:5000/health', (res) => {
      resolve(res.statusCode === 200);
    });
    req.on('error', () => resolve(false));
    req.setTimeout(1000, () => {
      req.destroy();
      resolve(false);
    });
  });
}

// Function to start service if not running
function startService() {
  return new Promise((resolve, reject) => {
    console.error('Starting MainAgentService...');
    const serviceProcess = spawn(AGENT_PATH, ['--http-server'], {
      detached: true,
      stdio: 'ignore',
      windowsHide: true
    });
    serviceProcess.unref();

    // Wait for service to start
    let attempts = 0;
    const checkInterval = setInterval(async () => {
      if (await isServiceRunning()) {
        clearInterval(checkInterval);
        resolve();
      } else if (attempts++ > 10) {
        clearInterval(checkInterval);
        reject(new Error('Failed to start service'));
      }
    }, 500);
  });
}

(async () => {
  const arg = process.argv.slice(2).join(' ').trim();
  const stdinData = await readStdin();
  const payload = arg || stdinData;

  if (!payload) {
    console.error('No JSON payload provided');
    process.exit(1);
  }

  try {
    // Ensure service is running
    if (!(await isServiceRunning())) {
      await startService();
    }

    // Send command via HTTP
    console.error('Sending command...');
    const postData = payload;
    const options = {
      hostname: 'localhost',
      port: 5000,
      path: '/command',
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Content-Length': Buffer.byteLength(postData)
      }
    };

    const response = await new Promise((resolve, reject) => {
      const req = http.request(options, (res) => {
        let body = '';
        res.on('data', (chunk) => body += chunk);
        res.on('end', () => resolve(body));
      });
      req.on('error', reject);
      req.write(postData);
      req.end();
    });

    process.stdout.write(response);
    process.exit(0);
  } catch (err) {
    console.error('Error:', err.message);
    process.exit(1);
  }
})();

param(
    [string]$PythonDir = ""
)

$ErrorActionPreference = "Stop"

Write-Host "[windows-desktop-automation] Starting bridges and agent..." -ForegroundColor Cyan

# Roots
$root = Split-Path -Parent (Split-Path -Parent $MyInvocation.MyCommand.Path)
$agentProj = Join-Path $root "src\src\MainAgentService\MainAgentService.csproj"
$pyBridge = Join-Path $root "src\bridge_python\bridge.py"

# Resolve Python from system install (preferred)
function Resolve-Python {
    # Prefer explicit -PythonDir if user passes one
    param([string]$Dir)

    if ($Dir -and (Test-Path (Join-Path $Dir "python.exe"))) {
        return (Join-Path $Dir "python.exe")
    }

    # Prefer Windows 'py' launcher if available (stable + versionable)
    if (Get-Command py -ErrorAction SilentlyContinue) {
        return "py"
    }

    return "python"
}

$PythonExe = Resolve-Python -Dir $PythonDir

Write-Host "Using Python: $PythonExe" -ForegroundColor Yellow

# If we're using the Windows launcher, target Python 3 explicitly
$PythonArgsPrefix = @()
if ($PythonExe -eq "py") { $PythonArgsPrefix = @("-3") }

# Start Python bridge (includes pywinauto, vision, WinRT OCR, context manager)
Write-Host "[python] launching bridge on :5001 (pywinauto + vision + WinRT OCR)" -ForegroundColor Yellow
$pyArgs = $PythonArgsPrefix + @("`"$pyBridge`"")
$py = Start-Process -FilePath $PythonExe -ArgumentList $pyArgs -WorkingDirectory (Split-Path $pyBridge) -PassThru -WindowStyle Hidden

# Start MainAgentService
Write-Host "[dotnet] launching MainAgentService (FlaUI)" -ForegroundColor Yellow
$agent = Start-Process -FilePath "dotnet" -ArgumentList "run --project `"$agentProj`"" -WorkingDirectory (Split-Path $agentProj) -PassThru -WindowStyle Hidden

Write-Host "All processes started." -ForegroundColor Green
Write-Host "PIDs => python: $($py.Id) | dotnet: $($agent.Id)" -ForegroundColor Green
Write-Host "Use stop-all.ps1 to terminate them."

Write-Host "Stopping windows-desktop-automation processes..." -ForegroundColor Cyan

$procNames = @("python", "python.exe", "dotnet", "dotnet.exe")
foreach ($p in Get-Process | Where-Object { $procNames -contains $_.Name }) {
    try {
        if ($p.Path -like "*python*" -or $p.Path -like "*dotnet*") {
            Write-Host "Killing $($p.Name) PID=$($p.Id)" -ForegroundColor Yellow
            $p.Kill()
        }
    } catch {}
}

Write-Host "Done." -ForegroundColor Green

/**
 * Windows Desktop Automation - Test Suite
 * 
 * Automated testing for all commands (v3.3)
 * 
 * Usage:
 *   node scripts/test-commands.cjs              # Run all tests
 *   node scripts/test-commands.cjs --category discovery  # Run category
 *   node scripts/test-commands.cjs --test explore        # Run single test
 *   node scripts/test-commands.cjs --list                # List all tests
 * 
 * Prerequisites:
 *   - MainAgentService must be built
 *   - Run from the skill root directory
 */

const { spawn } = require('child_process');
const path = require('path');
const fs = require('fs');

// ==================== CONFIGURATION ====================

const CONFIG = {
  agentPath: path.join(__dirname, '../src/src/MainAgentService/bin/Debug/net9.0-windows/MainAgentService.exe'),
  timeout: 15000,
  startupDelay: 1500,
  testApp: 'notepad.exe',
  testWindowTitle: 'Notepad',
  screenshotDir: path.join(__dirname, '../test-output'),
};

// ==================== COLORS ====================

const colors = {
  reset: '\x1b[0m',
  bright: '\x1b[1m',
  red: '\x1b[31m',
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  cyan: '\x1b[36m',
  gray: '\x1b[90m',
};

const log = {
  info: (msg) => console.log(`${colors.blue}[INFO]${colors.reset} ${msg}`),
  success: (msg) => console.log(`${colors.green}[PASS]${colors.reset} ${msg}`),
  fail: (msg) => console.log(`${colors.red}[FAIL]${colors.reset} ${msg}`),
  warn: (msg) => console.log(`${colors.yellow}[WARN]${colors.reset} ${msg}`),
  header: (msg) => console.log(`\n${colors.cyan}${colors.bright}=== ${msg} ===${colors.reset}\n`),
  detail: (msg) => console.log(`${colors.gray}       ${msg}${colors.reset}`),
};

// ==================== TEST RUNNER ====================

class TestRunner {
  constructor() {
    this.results = { passed: 0, failed: 0, skipped: 0, tests: [] };
    this.agentProcess = null;
    this.testAppPid = null;
  }

  /**
   * Sends a command to the agent and returns the parsed response
   */
  async sendCommand(command, options = {}) {
    return new Promise((resolve, reject) => {
      const timeout = options.timeout || CONFIG.timeout;
      const startupDelay = options.startupDelay || CONFIG.startupDelay;
      
      const child = spawn(CONFIG.agentPath, [], {
        stdio: ['pipe', 'pipe', 'pipe'],
        windowsHide: true,
      });

      let stdout = '';
      let stderr = '';
      let timer = null;

      child.stdout.on('data', (data) => { stdout += data.toString(); });
      child.stderr.on('data', (data) => { stderr += data.toString(); });

      timer = setTimeout(() => {
        child.kill();
        reject(new Error(`Timeout after ${timeout}ms`));
      }, timeout);

      setTimeout(() => {
        child.stdin.write(JSON.stringify(command) + '\n');
        child.stdin.write('{"action":"exit"}\n');
        child.stdin.end();
      }, startupDelay);

      child.on('close', (code) => {
        clearTimeout(timer);
        try {
          // Find JSON in output - look for command response (skip warnings)
          const lines = stdout.trim().split('\n');
          let response = null;
          let lastJson = null;
          
          for (const line of lines) {
            if (line.startsWith('{')) {
              try {
                const parsed = JSON.parse(line);
                lastJson = parsed;
                // Skip bridge warnings - look for actual command response
                if (parsed.status !== 'warn') {
                  response = parsed;
                  // Don't break - prefer later responses (command result comes after warnings)
                }
              } catch (e) { /* not valid JSON, continue */ }
            }
          }
          
          // If no non-warn response, use the last JSON we found
          if (!response && lastJson) {
            response = lastJson;
          }
          
          if (response) {
            resolve(response);
          } else {
            reject(new Error(`No valid JSON in response: ${stdout.substring(0, 200)}`));
          }
        } catch (e) {
          reject(new Error(`Parse error: ${e.message}`));
        }
      });

      child.on('error', (err) => {
        clearTimeout(timer);
        reject(err);
      });
    });
  }

  /**
   * Runs a single test case
   */
  async runTest(test) {
    const startTime = Date.now();
    try {
      // Run setup if defined
      if (test.setup) {
        await test.setup(this);
      }

      // Send the command
      const response = await this.sendCommand(test.command, test.options);
      
      // Validate the response
      let passed = true;
      let failReason = '';

      if (test.validate) {
        const result = test.validate(response);
        if (result !== true) {
          passed = false;
          failReason = typeof result === 'string' ? result : 'Validation failed';
        }
      } else {
        // Default validation: check for success status
        if (response.status !== 'success') {
          passed = false;
          failReason = response.message || response.code || 'Non-success status';
        }
      }

      // Run teardown if defined
      if (test.teardown) {
        await test.teardown(this);
      }

      const duration = Date.now() - startTime;
      
      if (passed) {
        this.results.passed++;
        log.success(`${test.name} (${duration}ms)`);
        if (test.showResponse) {
          log.detail(JSON.stringify(response, null, 2).split('\n').slice(0, 5).join('\n'));
        }
      } else {
        this.results.failed++;
        log.fail(`${test.name} - ${failReason}`);
        log.detail(`Response: ${JSON.stringify(response).substring(0, 200)}`);
      }

      this.results.tests.push({ name: test.name, passed, duration, failReason });
      return passed;
    } catch (error) {
      this.results.failed++;
      log.fail(`${test.name} - ${error.message}`);
      this.results.tests.push({ name: test.name, passed: false, failReason: error.message });
      return false;
    }
  }

  /**
   * Runs all tests in a category
   */
  async runCategory(category, tests) {
    log.header(category);
    for (const test of tests) {
      await this.runTest(test);
    }
  }

  /**
   * Prints the final summary
   */
  printSummary() {
    log.header('TEST SUMMARY');
    console.log(`  ${colors.green}Passed:${colors.reset}  ${this.results.passed}`);
    console.log(`  ${colors.red}Failed:${colors.reset}  ${this.results.failed}`);
    console.log(`  ${colors.yellow}Skipped:${colors.reset} ${this.results.skipped}`);
    console.log(`  ${colors.blue}Total:${colors.reset}   ${this.results.passed + this.results.failed + this.results.skipped}`);
    
    if (this.results.failed > 0) {
      console.log(`\n${colors.red}Failed Tests:${colors.reset}`);
      this.results.tests
        .filter(t => !t.passed)
        .forEach(t => console.log(`  - ${t.name}: ${t.failReason}`));
    }
    
    return this.results.failed === 0;
  }

  /**
   * Helper to launch test app (Notepad)
   */
  async launchTestApp() {
    try {
      const response = await this.sendCommand({
        action: 'launch_app',
        path: CONFIG.testApp,
        wait_for_window: CONFIG.testWindowTitle
      });
      if (response.status === 'success' && response.pid) {
        this.testAppPid = response.pid;
      }
      // Give window time to fully render
      await this.sleep(500);
      return response;
    } catch (e) {
      log.warn(`Failed to launch test app: ${e.message}`);
      return null;
    }
  }

  /**
   * Helper to close test app
   */
  async closeTestApp() {
    try {
      // Try to close gracefully first
      await this.sendCommand({ action: 'close_window', selector: CONFIG.testWindowTitle });
      await this.sleep(200);
      // Handle "Save?" dialog if it appears
      await this.sendCommand({ action: 'key_press', key: 'n' });
    } catch (e) {
      // If close fails, try kill
      if (this.testAppPid) {
        await this.sendCommand({ action: 'kill_process', pid: this.testAppPid, force: true });
      }
    }
    this.testAppPid = null;
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// ==================== TEST DEFINITIONS ====================

const TESTS = {
  // -------------------- DISCOVERY --------------------
  discovery: [
    {
      name: 'explore - list windows',
      command: { action: 'explore' },
      validate: (r) => r.status === 'success' && Array.isArray(r.data) && r.data.length >= 0,
      showResponse: false,
    },
    {
      name: 'explore_window - explore test window',
      command: { action: 'explore_window', selector: 'Notepad', max_depth: 2 },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success' && (Array.isArray(r.elements) || Array.isArray(r.data)),
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'find_element - find button in Notepad',
      command: { action: 'find_element', selector: 'Edit', window: 'Notepad' },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success' || (r.status === 'error' && r.code === 'ELEMENT_NOT_FOUND'),
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'get_window_info - get window details',
      command: { action: 'get_window_info', selector: 'Notepad' },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success' && r.data && typeof r.data.title === 'string',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
  ],

  // -------------------- WINDOW MANAGEMENT --------------------
  windowManagement: [
    {
      name: 'focus_window - bring window to front',
      command: { action: 'focus_window', selector: 'Notepad' },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'wait_for_window - wait for window to appear',
      command: { action: 'launch_app', path: 'notepad.exe', wait_for_window: 'Notepad' },
      validate: (r) => r.status === 'success' && r.pid > 0,
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'move_window - move to coordinates',
      command: { action: 'move_window', selector: 'Notepad', x: 100, y: 100 },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'resize_window - resize window',
      command: { action: 'resize_window', selector: 'Notepad', width: 800, height: 600 },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'minimize_window - minimize window',
      command: { action: 'minimize_window', selector: 'Notepad' },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'maximize_window - maximize window',
      command: { action: 'maximize_window', selector: 'Notepad' },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'restore_window - restore window',
      command: { action: 'restore_window', selector: 'Notepad' },
      setup: async (runner) => { 
        await runner.launchTestApp();
        await runner.sendCommand({ action: 'maximize_window', selector: 'Notepad' });
        await runner.sleep(200);
      },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'close_window - close window',
      command: { action: 'close_window', selector: 'Notepad' },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success',
    },
  ],

  // -------------------- APP/PROCESS CONTROL --------------------
  appProcess: [
    {
      name: 'launch_app - launch notepad',
      command: { action: 'launch_app', path: 'notepad.exe', wait_for_window: 'Notepad' },
      validate: (r) => r.status === 'success' && r.pid > 0,
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'list_processes - list all',
      command: { action: 'list_processes' },
      validate: (r) => r.status === 'success' && Array.isArray(r.data) && r.data.length > 0,
    },
    {
      name: 'list_processes - filter by name',
      command: { action: 'list_processes', filter: 'notepad' },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success' && Array.isArray(r.data),
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'kill_process - kill by name',
      command: { action: 'kill_process', name: 'notepad' },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success',
    },
  ],

  // -------------------- MOUSE ACTIONS --------------------
  mouse: [
    {
      name: 'click_at - click at coordinates',
      command: { action: 'click_at', x: 500, y: 300 },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'click_at - right click',
      command: { action: 'click_at', x: 500, y: 300, button: 'right' },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'mouse_move - move to coordinates',
      command: { action: 'mouse_move', x: 400, y: 400 },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'scroll - scroll down',
      command: { action: 'scroll', direction: 'down', amount: 100 },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'scroll - scroll up',
      command: { action: 'scroll', direction: 'up', amount: 100 },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'drag_and_drop - drag between coordinates',
      command: { action: 'drag_and_drop', from_x: 200, from_y: 200, to_x: 400, to_y: 400 },
      validate: (r) => r.status === 'success',
    },
  ],

  // -------------------- KEYBOARD ACTIONS --------------------
  keyboard: [
    {
      name: 'hotkey - ctrl+a',
      command: { action: 'hotkey', keys: 'ctrl+a' },
      setup: async (runner) => { 
        await runner.launchTestApp(); 
        await runner.sendCommand({ action: 'focus_window', selector: 'Notepad' });
      },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'key_press - press escape',
      command: { action: 'key_press', key: 'escape' },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'key_press - press enter',
      command: { action: 'key_press', key: 'enter' },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'type - type text',
      command: { action: 'type', selector: 'Notepad', text: 'Hello Test!' },
      setup: async (runner) => { 
        await runner.launchTestApp(); 
        await runner.sendCommand({ action: 'focus_window', selector: 'Notepad' });
      },
      validate: (r) => r.status === 'success' || r.code === 'ELEMENT_NOT_FOUND',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
  ],

  // -------------------- CLIPBOARD --------------------
  clipboard: [
    {
      name: 'set_clipboard - write text',
      command: { action: 'set_clipboard', text: 'Test clipboard content' },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'get_clipboard - read text',
      command: { action: 'get_clipboard' },
      setup: async (runner) => {
        await runner.sendCommand({ action: 'set_clipboard', text: 'Verify clipboard' });
      },
      validate: (r) => r.status === 'success' && typeof r.text === 'string',
    },
  ],

  // -------------------- TEXT/OCR & SCREENSHOT --------------------
  textAndScreenshot: [
    {
      name: 'read_text - read from element',
      command: { action: 'read_text', selector: 'Notepad' },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success' || r.status === 'error', // May fail if OCR not available
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'screenshot - capture screen',
      command: { action: 'screenshot', filename: 'test-screenshot.png' },
      validate: (r) => r.status === 'success',
    },
  ],

  // -------------------- ERROR HANDLING --------------------
  errorHandling: [
    {
      name: 'missing_param - returns MISSING_PARAM error',
      command: { action: 'focus_window' }, // Missing selector
      validate: (r) => r.status === 'error' && r.code === 'MISSING_PARAM',
    },
    {
      name: 'window_not_found - returns WINDOW_NOT_FOUND error',
      command: { action: 'focus_window', selector: 'NonExistentWindow12345' },
      validate: (r) => r.status === 'error' && r.code === 'WINDOW_NOT_FOUND',
    },
    {
      name: 'unknown_action - returns UNKNOWN_ACTION error',
      command: { action: 'nonexistent_action' },
      validate: (r) => r.status === 'error' && r.code === 'UNKNOWN_ACTION',
    },
  ],

  // -------------------- SYSTEM (v3.2) --------------------
  system: [
    {
      name: 'health - system health check',
      command: { action: 'health' },
      validate: (r) => r.status === 'success' && r.version && r.bridges,
    },
  ],

  // -------------------- MULTI-MONITOR (v3.2) --------------------
  multiMonitor: [
    {
      name: 'list_monitors - enumerate displays',
      command: { action: 'list_monitors' },
      validate: (r) => r.status === 'success' && Array.isArray(r.data) && r.data.length >= 1,
    },
    {
      name: 'screenshot_monitor - capture primary monitor',
      command: { action: 'screenshot_monitor', monitor: 0, filename: 'test-monitor-0.png' },
      validate: (r) => r.status === 'success' && r.filename,
    },
    {
      name: 'screenshot_monitor - invalid monitor returns error',
      command: { action: 'screenshot_monitor', monitor: 99 },
      validate: (r) => r.status === 'error' && r.code === 'INVALID_MONITOR',
    },
    {
      name: 'move_to_monitor - move window to primary monitor',
      command: { action: 'move_to_monitor', selector: 'Notepad', monitor: 0, position: 'center' },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
  ],

  // -------------------- FILE DIALOG (v3.2) --------------------
  fileDialog: [
    {
      name: 'file_dialog - detect when no dialog open',
      command: { action: 'file_dialog', dialog_action: 'detect' },
      validate: (r) => r.status === 'error' && r.code === 'DIALOG_NOT_FOUND',
    },
    {
      name: 'file_dialog - invalid action',
      command: { action: 'file_dialog', dialog_action: 'invalid_action' },
      validate: (r) => r.status === 'error' && r.code === 'INVALID_DIALOG_ACTION',
    },
  ],

  // -------------------- WAIT FOR ELEMENT (v3.2) --------------------
  waitForElement: [
    {
      name: 'wait_for_element - find existing element',
      command: { action: 'wait_for_element', selector: 'Edit', window: 'Notepad', timeout: 3000 },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success' || (r.status === 'error' && r.code === 'TIMEOUT'),
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'wait_for_element - timeout for non-existent element',
      command: { action: 'wait_for_element', selector: 'NonExistentElement99', timeout: 1000, poll_interval: 200 },
      validate: (r) => r.status === 'error' && r.code === 'TIMEOUT',
    },
  ],

  // -------------------- BATCH (v3.2) --------------------
  batch: [
    {
      name: 'batch - execute simple command sequence',
      command: { 
        action: 'batch', 
        commands: [
          { action: 'set_clipboard', text: 'batch_test_1' },
          { action: 'get_clipboard' }
        ],
        stop_on_error: true 
      },
      validate: (r) => r.status === 'success' && r.succeeded === 2 && r.failed === 0,
    },
    {
      name: 'batch - stop on error',
      command: { 
        action: 'batch', 
        commands: [
          { action: 'set_clipboard', text: 'before_error' },
          { action: 'focus_window', selector: 'NonExistentWindow12345' },
          { action: 'set_clipboard', text: 'after_error' }
        ],
        stop_on_error: true 
      },
      validate: (r) => r.status === 'error' && r.succeeded === 1 && r.failed === 1,
    },
    {
      name: 'batch - continue on error',
      command: { 
        action: 'batch', 
        commands: [
          { action: 'set_clipboard', text: 'before_error' },
          { action: 'focus_window', selector: 'NonExistentWindow12345' },
          { action: 'set_clipboard', text: 'after_error' }
        ],
        stop_on_error: false 
      },
      validate: (r) => r.succeeded === 2 && r.failed === 1,
    },
  ],

  // -------------------- ADVANCED MOUSE (v3.3) --------------------
  advancedMouse: [
    {
      name: 'mouse_path - move along waypoints',
      command: { action: 'mouse_path', points: [[100, 100], [200, 150], [300, 100]], duration: 300 },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'mouse_bezier - move along bezier curve',
      command: { action: 'mouse_bezier', start: [100, 100], control1: [150, 50], control2: [250, 50], end: [300, 100], steps: 30, duration: 300 },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'draw - draw path',
      command: { action: 'draw', points: [[100, 100], [150, 120], [200, 100]], button: 'left', duration: 300 },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'mouse_down - press left button',
      command: { action: 'mouse_down', button: 'left', x: 400, y: 400 },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'mouse_up - release left button',
      command: { action: 'mouse_up', button: 'left' },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'click_relative - click relative to element',
      command: { action: 'click_relative', selector: 'Notepad', anchor: 'center', offset_x: 10, offset_y: 10 },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
  ],

  // -------------------- ADVANCED KEYBOARD (v3.3) --------------------
  advancedKeyboard: [
    {
      name: 'key_down - press shift',
      command: { action: 'key_down', key: 'shift' },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'key_up - release shift',
      command: { action: 'key_up', key: 'shift' },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'type_here - type at cursor',
      command: { action: 'type_here', text: 'Test typing' },
      setup: async (runner) => { 
        await runner.launchTestApp(); 
        await runner.sendCommand({ action: 'focus_window', selector: 'Notepad' });
      },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'type_at_cursor - alias for type_here',
      command: { action: 'type_at_cursor', text: 'More text' },
      setup: async (runner) => { 
        await runner.launchTestApp(); 
        await runner.sendCommand({ action: 'focus_window', selector: 'Notepad' });
      },
      validate: (r) => r.status === 'success',
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
  ],

  // -------------------- WAIT FOR STATE (v3.3) --------------------
  waitForState: [
    {
      name: 'wait_for_state - element exists',
      command: { action: 'wait_for_state', selector: 'Edit', state: 'exists', window: 'Notepad', timeout: 3000 },
      setup: async (runner) => { await runner.launchTestApp(); },
      validate: (r) => r.status === 'success' || (r.status === 'error' && r.code === 'TIMEOUT'),
      teardown: async (runner) => { await runner.closeTestApp(); },
    },
    {
      name: 'wait_for_state - element not_exists (timeout expected)',
      command: { action: 'wait_for_state', selector: 'NonExistent99', state: 'not_exists', timeout: 1000 },
      validate: (r) => r.status === 'success',
    },
    {
      name: 'wait_for_state - invalid state returns error',
      command: { action: 'wait_for_state', selector: 'Button', state: 'invalid_state', timeout: 1000 },
      validate: (r) => r.status === 'error',
    },
  ],

  // -------------------- OCR REGION (v3.3) --------------------
  ocrRegion: [
    {
      name: 'ocr_region - read screen region',
      command: { action: 'ocr_region', x: 100, y: 100, width: 200, height: 50 },
      // OCR may fail if Java bridge is not running, which is acceptable
      validate: (r) => r.status === 'success' || (r.status === 'error' && (r.code === 'OCR_FAILED' || r.code === 'OCR_REGION_FAILED')),
    },
    {
      name: 'ocr_region - missing parameters',
      command: { action: 'ocr_region', x: 100, y: 100 }, // missing width/height
      validate: (r) => r.status === 'error' && r.code === 'MISSING_PARAM',
    },
  ],
};

// ==================== MAIN EXECUTION ====================

async function main() {
  const args = process.argv.slice(2);
  const runner = new TestRunner();

  // Parse arguments
  let categoryFilter = null;
  let testFilter = null;
  let listOnly = false;

  for (let i = 0; i < args.length; i++) {
    if (args[i] === '--category' && args[i + 1]) {
      categoryFilter = args[i + 1].toLowerCase();
      i++;
    } else if (args[i] === '--test' && args[i + 1]) {
      testFilter = args[i + 1].toLowerCase();
      i++;
    } else if (args[i] === '--list') {
      listOnly = true;
    } else if (args[i] === '--help') {
      console.log(`
Windows Desktop Automation Test Suite

Usage:
  node test-commands.cjs              Run all tests
  node test-commands.cjs --category discovery  Run category
  node test-commands.cjs --test explore        Run single test
  node test-commands.cjs --list                List all tests
  node test-commands.cjs --help                Show this help

Categories: ${Object.keys(TESTS).join(', ')}
`);
      process.exit(0);
    }
  }

  // List tests
  if (listOnly) {
    console.log('\nAvailable Tests:\n');
    for (const [category, tests] of Object.entries(TESTS)) {
      console.log(`${colors.cyan}${category}${colors.reset}`);
      tests.forEach(t => console.log(`  - ${t.name}`));
    }
    process.exit(0);
  }

  // Verify agent exists
  if (!fs.existsSync(CONFIG.agentPath)) {
    log.fail(`Agent not found at: ${CONFIG.agentPath}`);
    log.info('Run: dotnet build (in MainAgentService directory)');
    process.exit(1);
  }

  // Create test output directory
  if (!fs.existsSync(CONFIG.screenshotDir)) {
    fs.mkdirSync(CONFIG.screenshotDir, { recursive: true });
  }

  log.header('WINDOWS DESKTOP AUTOMATION TEST SUITE');
  log.info(`Agent: ${CONFIG.agentPath}`);
  log.info(`Timeout: ${CONFIG.timeout}ms`);

  // Run tests
  for (const [category, tests] of Object.entries(TESTS)) {
    if (categoryFilter && category.toLowerCase() !== categoryFilter) continue;

    let filteredTests = tests;
    if (testFilter) {
      filteredTests = tests.filter(t => t.name.toLowerCase().includes(testFilter));
    }

    if (filteredTests.length > 0) {
      await runner.runCategory(category, filteredTests);
    }
  }

  // Print summary
  const success = runner.printSummary();
  process.exit(success ? 0 : 1);
}

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