skopix 2.0.0

package/cli/commands/init.js

@@ -0,0 +1,190 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function initCommand() {
+  console.log(chalk.cyan.bold('\n  Skopix Setup\n'));
+  console.log(chalk.dim('  This will create a .skopix.env file in your current directory.\n'));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'provider',
+      message: 'Which LLM provider would you like to use?',
+      choices: [
+        { name: 'Google Gemini (free tier available)', value: 'gemini' },
+        { name: 'Ollama (local, completely free)', value: 'ollama' },
+        { name: 'OpenAI GPT-4 Vision', value: 'openai' },
+      ],
+    },
+    {
+      type: 'input',
+      name: 'geminiKey',
+      message: 'Enter your Gemini API key:',
+      when: (a) => a.provider === 'gemini',
+      validate: (v) => v.trim().length > 0 || 'API key is required',
+    },
+    {
+      type: 'input',
+      name: 'ollamaUrl',
+      message: 'Ollama base URL:',
+      default: 'http://localhost:11434',
+      when: (a) => a.provider === 'ollama',
+    },
+    {
+      type: 'input',
+      name: 'ollamaModel',
+      message: 'Ollama model name (must support vision or text):',
+      default: 'llama3.1',
+      when: (a) => a.provider === 'ollama',
+    },
+    {
+      type: 'input',
+      name: 'openaiKey',
+      message: 'Enter your OpenAI API key:',
+      when: (a) => a.provider === 'openai',
+      validate: (v) => v.trim().length > 0 || 'API key is required',
+    },
+    {
+      type: 'confirm',
+      name: 'setupJira',
+      message: 'Would you like to set up Jira integration?',
+      default: false,
+    },
+    {
+      type: 'input',
+      name: 'jiraUrl',
+      message: 'Jira base URL (e.g. https://yourorg.atlassian.net):',
+      when: (a) => a.setupJira,
+    },
+    {
+      type: 'input',
+      name: 'jiraEmail',
+      message: 'Jira account email:',
+      when: (a) => a.setupJira,
+    },
+    {
+      type: 'password',
+      name: 'jiraToken',
+      message: 'Jira API token (https://id.atlassian.com/manage-profile/security/api-tokens):',
+      when: (a) => a.setupJira,
+    },
+    {
+      type: 'input',
+      name: 'jiraProject',
+      message: 'Jira project key (e.g. QA, BUG):',
+      when: (a) => a.setupJira,
+    },
+    {
+      type: 'confirm',
+      name: 'setupLinear',
+      message: 'Would you like to set up Linear integration?',
+      default: false,
+    },
+    {
+      type: 'password',
+      name: 'linearKey',
+      message: 'Linear API key:',
+      when: (a) => a.setupLinear,
+    },
+    {
+      type: 'input',
+      name: 'linearTeam',
+      message: 'Linear team ID:',
+      when: (a) => a.setupLinear,
+    },
+    {
+      type: 'confirm',
+      name: 'setupGithub',
+      message: 'Would you like to set up GitHub Issues integration?',
+      default: false,
+    },
+    {
+      type: 'input',
+      name: 'githubRepo',
+      message: 'GitHub repo (e.g. owner/repo):',
+      when: (a) => a.setupGithub,
+    },
+    {
+      type: 'password',
+      name: 'githubToken',
+      message: 'GitHub personal access token:',
+      when: (a) => a.setupGithub,
+    },
+  ]);
+
+  // Build env file content
+  const lines = [
+    '# Skopix Configuration',
+    '# Generated by skopix init',
+    '',
+    `SKOPIX_PROVIDER=${answers.provider}`,
+    '',
+  ];
+
+  if (answers.provider === 'gemini') {
+    lines.push(`GEMINI_API_KEY=${answers.geminiKey}`);
+  } else if (answers.provider === 'ollama') {
+    lines.push(`OLLAMA_BASE_URL=${answers.ollamaUrl}`);
+    lines.push(`OLLAMA_MODEL=${answers.ollamaModel}`);
+  } else if (answers.provider === 'openai') {
+    lines.push(`OPENAI_API_KEY=${answers.openaiKey}`);
+  }
+
+  if (answers.setupJira) {
+    lines.push('', '# Jira');
+    lines.push(`JIRA_BASE_URL=${answers.jiraUrl}`);
+    lines.push(`JIRA_EMAIL=${answers.jiraEmail}`);
+    lines.push(`JIRA_API_TOKEN=${answers.jiraToken}`);
+    lines.push(`JIRA_PROJECT_KEY=${answers.jiraProject}`);
+  }
+
+  if (answers.setupLinear) {
+    lines.push('', '# Linear');
+    lines.push(`LINEAR_API_KEY=${answers.linearKey}`);
+    lines.push(`LINEAR_TEAM_ID=${answers.linearTeam}`);
+  }
+
+  if (answers.setupGithub) {
+    lines.push('', '# GitHub');
+    lines.push(`GITHUB_REPO=${answers.githubRepo}`);
+    lines.push(`GITHUB_TOKEN=${answers.githubToken}`);
+  }
+
+  const envPath = path.resolve(process.cwd(), '.skopix.env');
+  await fs.writeFile(envPath, lines.join('\n') + '\n');
+
+  // Also create a sample credentials file
+  const credsSample = [
+    '# Skopix credentials file',
+    '# Use with: skopix run --credentials credentials.yaml',
+    '# Values are passed to the AI agent for form filling',
+    '',
+    'credentials:',
+    '  - label: "Main test account"',
+    '    fields:',
+    '      email: "testuser@example.com"',
+    '      password: "yourpassword"',
+    '      username: "testuser"',
+    '',
+    '  - label: "Admin account"',
+    '    fields:',
+    '      email: "admin@example.com"',
+    '      password: "adminpassword"',
+  ].join('\n');
+
+  const credsPath = path.resolve(process.cwd(), 'credentials.yaml');
+  if (!await fs.pathExists(credsPath)) {
+    await fs.writeFile(credsPath, credsSample);
+    console.log(chalk.dim(`\n  Sample credentials file created → credentials.yaml`));
+  }
+
+  console.log(chalk.green.bold('\n  ✓ Configuration saved → .skopix.env'));
+  console.log(chalk.dim('\n  Add .skopix.env to your .gitignore to keep secrets safe!\n'));
+  console.log(chalk.white('  You\'re ready to go. Try:'));
+  console.log(chalk.cyan('  skopix run --url https://yoursite.com --goal "test the login flow"\n'));
+}

package/cli/commands/report.js

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs-extra';
+import open from 'open';
+
+export async function reportCommand(options) {
+  const dir = path.resolve(options.dir);
+
+  if (!await fs.pathExists(dir)) {
+    console.log(chalk.red(`\n  No reports found at: ${dir}\n`));
+    process.exit(1);
+  }
+
+  let sessions = await fs.readdir(dir);
+  sessions = sessions.filter(s => !s.startsWith('.'));
+
+  if (sessions.length === 0) {
+    console.log(chalk.yellow('\n  No sessions found. Run a test first!\n'));
+    process.exit(0);
+  }
+
+  // Sort by actual modification time (most recent first)
+  const withStats = await Promise.all(
+    sessions.map(async (s) => {
+      const stat = await fs.stat(path.join(dir, s));
+      return { name: s, mtime: stat.mtime };
+    })
+  );
+  const sorted = withStats.sort((a, b) => b.mtime - a.mtime);
+  const latest = sorted[0].name;
+  const reportPath = path.join(dir, latest, 'report.html');
+
+  if (!await fs.pathExists(reportPath)) {
+    console.log(chalk.red(`\n  Report not found: ${reportPath}\n`));
+    process.exit(1);
+  }
+
+  console.log(chalk.green(`\n  Opening report: ${reportPath}\n`));
+  console.log(chalk.dim(`  Session: ${latest}\n`));
+  await open(reportPath);
+}

package/cli/commands/run.js

@@ -0,0 +1,350 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import fs from 'fs-extra';
+import { v4 as uuidv4 } from 'uuid';
+import { BrowserAgent } from '../../core/browser.js';
+import { LLMRouter } from '../../core/llm.js';
+import { ReportGenerator } from '../../core/reporter.js';
+import { IssueTracker } from '../../core/tracker.js';
+import { loadCredentials } from '../../core/credentials.js';
+import { formatStep, formatIssue, printSummary } from '../ui.js';
+
+export async function runCommand(options) {
+  const sessionId = uuidv4().slice(0, 8);
+  const startTime = Date.now();
+
+  console.log(chalk.cyan('━'.repeat(60)));
+  console.log(chalk.white.bold(`  Session: `) + chalk.yellow(sessionId));
+  console.log(chalk.white.bold(`  Target:  `) + chalk.green(options.url));
+  console.log(chalk.white.bold(`  Goal:    `) + chalk.white(options.goal));
+  console.log(chalk.white.bold(`  Provider:`) + chalk.magenta(options.provider));
+  console.log(chalk.cyan('━'.repeat(60)));
+  console.log();
+
+  // Load credentials if provided
+  let credentials = {};
+  if (options.credentials) {
+    const spinner = ora('Loading credentials...').start();
+    try {
+      credentials = await loadCredentials(options.credentials);
+      spinner.succeed(chalk.green(`Credentials loaded (${Object.keys(credentials).length} entries)`));
+    } catch (err) {
+      spinner.fail(chalk.red(`Failed to load credentials: ${err.message}`));
+      process.exit(1);
+    }
+  }
+
+  // Set up output directory
+  const outputDir = path.resolve(options.output, sessionId);
+  await fs.ensureDir(outputDir);
+
+  // Initialise LLM
+  const spinner = ora('Initialising AI agent...').start();
+  let llm;
+  try {
+    llm = new LLMRouter(options.provider, options.model);
+    await llm.verify();
+    spinner.succeed(chalk.green(`AI agent ready (${llm.modelName})`));
+  } catch (err) {
+    spinner.fail(chalk.red(`LLM init failed: ${err.message}`));
+    console.log(chalk.yellow('\n  Hint: Run `skopix init` to configure your API keys.\n'));
+    process.exit(1);
+  }
+
+  // Launch browser
+  const browserSpinner = ora('Launching browser...').start();
+  const agent = new BrowserAgent({
+    headless: options.headless,
+    videoDir: options.video !== false ? outputDir : null,
+    sessionId,
+  });
+
+  try {
+    await agent.launch();
+    browserSpinner.succeed(chalk.green('Browser launched'));
+  } catch (err) {
+    browserSpinner.fail(chalk.red(`Browser failed: ${err.message}`));
+    process.exit(1);
+  }
+
+  // Navigate to URL
+  const navSpinner = ora(`Navigating to ${options.url}...`).start();
+  try {
+    await agent.goto(options.url);
+    navSpinner.succeed(chalk.green(`Loaded: ${options.url}`));
+  } catch (err) {
+    navSpinner.fail(chalk.red(`Navigation failed: ${err.message}`));
+    await agent.close();
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(chalk.cyan.bold('  ◆ Agent loop starting\n'));
+
+  const steps = [];
+  const issues = [];
+  const maxSteps = parseInt(options.maxSteps);
+  let goalAchieved = false;
+  let stuck = false;
+  let previousDOMHash = null;
+  let stuckCount = 0;
+
+  // ─── MAIN AGENT LOOP ────────────────────────────────────────────────────────
+  for (let step = 1; step <= maxSteps; step++) {
+    const stepSpinner = ora({
+      text: chalk.dim(`Step ${step}/${maxSteps} — extracting page state...`),
+      color: 'cyan',
+    }).start();
+
+    let domSnapshot, screenshot;
+    try {
+      domSnapshot = await agent.extractDOM();
+      screenshot = await agent.screenshot(path.join(outputDir, `step-${step}.png`));
+    } catch (err) {
+      stepSpinner.fail(chalk.red(`DOM extraction failed: ${err.message}`));
+      break;
+    }
+
+    // Detect if we're stuck - allow 5 unchanged DOM snapshots before giving up
+    // Skip stuck detection if last action was OBSERVE (no DOM change expected)
+    const lastAction = steps.length > 0 ? steps[steps.length - 1].action : null;
+    const currentHash = simpleHash(domSnapshot.text);
+    if (currentHash === previousDOMHash && lastAction !== 'OBSERVE') {
+      stuckCount++;
+      if (stuckCount >= 5) {
+        stepSpinner.warn(chalk.yellow('Agent appears stuck — no DOM changes detected after 5 attempts'));
+        stuck = true;
+        break;
+      }
+    } else {
+      stuckCount = 0;
+    }
+    previousDOMHash = currentHash;
+
+    // Ask LLM what to do next
+    stepSpinner.text = chalk.dim(`Step ${step}/${maxSteps} — reasoning...`);
+
+    let decision;
+    try {
+      decision = await llm.decide({
+        goal: options.goal,
+        url: options.url,
+        currentUrl: await agent.currentUrl(),
+        domSnapshot: domSnapshot.text,
+        stepNumber: step,
+        previousSteps: steps.slice(-5), // Last 5 for context
+        credentials,
+      });
+    } catch (err) {
+      stepSpinner.fail(chalk.red(`LLM reasoning failed: ${err.message}`));
+      break;
+    }
+
+    // Execute the action
+    stepSpinner.text = chalk.dim(`Step ${step}/${maxSteps} — executing: ${decision.action}...`);
+
+    let actionResult = { success: false, error: null };
+    try {
+      actionResult = await agent.executeAction(decision);
+    } catch (err) {
+      actionResult = { success: false, error: err.message };
+    }
+
+    // Record the step
+    const stepRecord = {
+      step,
+      url: await agent.currentUrl(),
+      action: decision.action,
+      target: decision.target,
+      value: decision.value ? '***' : undefined,
+      reasoning: decision.reasoning,
+      observation: decision.observation,
+      confidence: decision.confidence,
+      issues: decision.issues || [],
+      success: actionResult.success,
+      error: actionResult.error,
+      screenshot: `step-${step}.png`,
+      batchResults: actionResult.batchResults || null,
+      batchSize: decision.actions ? decision.actions.length : null,
+      actions: decision.actions || null,
+      timestamp: new Date().toISOString(),
+    };
+
+    steps.push(stepRecord);
+
+    // Collect issues - aggressively deduplicate similar ones across steps
+    if (decision.issues && decision.issues.length > 0) {
+      for (const issue of decision.issues) {
+        // Build a stricter fingerprint that catches semantic duplicates
+        // - Strip common variation words ("with", "during", filler), normalise whitespace
+        // - Use first 5 meaningful words rather than first 30 chars
+        const normaliseTitle = (t) => {
+          return (t || '')
+            .toLowerCase()
+            .replace(/[^a-z0-9\s]/g, ' ')
+            .replace(/\b(the|a|an|with|of|on|in|for|to|and|or|when|during|at|that)\b/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim()
+            .split(' ')
+            .filter(Boolean)
+            .slice(0, 5)
+            .join(' ');
+        };
+        const fingerprint = normaliseTitle(issue.title) + '|' + (issue.type || '');
+        const isDuplicate = issues.some(existing => {
+          const existingFp = normaliseTitle(existing.title) + '|' + (existing.type || '');
+          // Either fingerprints match OR one title is a substring of the other
+          if (existingFp === fingerprint) return true;
+          const a = (existing.title || '').toLowerCase();
+          const b = (issue.title || '').toLowerCase();
+          // Detect cases like "Login failed with invalid credentials" vs "Login failed with incorrect credentials"
+          // by checking if they share most meaningful words
+          const aWords = new Set(normaliseTitle(a).split(' '));
+          const bWords = new Set(normaliseTitle(b).split(' '));
+          if (aWords.size === 0 || bWords.size === 0) return false;
+          const overlap = [...aWords].filter(w => bWords.has(w)).length;
+          const minSize = Math.min(aWords.size, bWords.size);
+          // 60%+ word overlap = same issue
+          return minSize > 0 && (overlap / minSize) >= 0.6;
+        });
+        if (!isDuplicate) {
+          issues.push({
+            ...issue,
+            step,
+            url: stepRecord.url,
+            screenshot: `step-${step}.png`,
+          });
+        }
+      }
+    }
+
+    // Print step output
+    stepSpinner.stop();
+    formatStep(stepRecord, step, maxSteps);
+
+    // Check if goal is complete
+    if (decision.goalAchieved) {
+      console.log();
+      console.log(chalk.green.bold('  ✓ Goal achieved!'));
+      goalAchieved = true;
+      break;
+    }
+
+    // Auto-detect goal completion based on URL/page changes for common goals
+    // Heuristic auto-detection of login success/failure was removed.
+    // It would force goalAchieved=true on simple login-goal keyword matches,
+    // causing multi-step goals like "log in AND open Dates category" to false-pass
+    // after just typing into the form. The LLM is now responsible for setting
+    // goalAchieved based on the full goal, with explicit prompt guidance on
+    // reading the goal literally and only marking achieved when the actual
+    // required outcome was observed.
+
+    if (decision.action === 'STOP') {
+      console.log();
+      console.log(chalk.yellow('  ⚠ Agent decided to stop: ') + chalk.white(decision.reasoning));
+      break;
+    }
+
+    // Small delay between steps
+    await sleep(150);
+  }
+
+  console.log();
+  console.log(chalk.cyan('━'.repeat(60)));
+
+  // Stop recording
+  const closeSpinner = ora('Finalising session...').start();
+  let videoPath = null;
+  try {
+    videoPath = await agent.close();
+    closeSpinner.succeed(chalk.green('Browser closed'));
+  } catch (err) {
+    closeSpinner.warn(chalk.yellow(`Browser close warning: ${err.message}`));
+  }
+
+  // Test pass/fail is based purely on whether the goal was achieved.
+  // Issues found during the test are reported separately - they're observations the agent
+  // noticed but they do not influence the pass/fail status unless directly related to the goal.
+  const actuallyPassed = goalAchieved;
+  const failReason = null;
+
+  // Generate report
+  const reportSpinner = ora('Generating report...').start();
+  const reporter = new ReportGenerator(outputDir, sessionId);
+  let reportPath;
+  try {
+    reportPath = await reporter.generate({
+      sessionId,
+      url: options.url,
+      goal: options.goal,
+      steps,
+      issues,
+      goalAchieved: actuallyPassed,
+      goalActuallyAchieved: goalAchieved,
+      failReason,
+      stuck,
+      videoPath,
+      duration: Date.now() - startTime,
+      provider: options.provider,
+      model: llm.modelName,
+    });
+    reportSpinner.succeed(chalk.green(`Report saved → ${reportPath}`));
+  } catch (err) {
+    reportSpinner.fail(chalk.red(`Report generation failed: ${err.message}`));
+  }
+
+  // Push to issue tracker if requested
+  if ((options.jira || options.linear || options.github) && issues.length > 0) {
+    const trackerSpinner = ora('Pushing issues to tracker...').start();
+    try {
+      const tracker = new IssueTracker({ jira: options.jira, linear: options.linear, github: options.github });
+      const created = await tracker.pushIssues(issues, { url: options.url, goal: options.goal, sessionId });
+      const newCount = created.filter(c => c.action === 'created').length;
+      const commentedCount = created.filter(c => c.action === 'commented').length;
+      const semanticCount = created.filter(c => c.action === 'commented' && c.matchedBy === 'semantic').length;
+      let summary;
+      if (newCount > 0 && commentedCount > 0) {
+        summary = `${newCount} new issue(s), ${commentedCount} existing issue(s) updated`;
+        if (semanticCount > 0) summary += ` (${semanticCount} matched semantically)`;
+      } else if (commentedCount > 0) {
+        summary = `${commentedCount} existing issue(s) updated (already known)`;
+        if (semanticCount > 0) summary += ` — ${semanticCount} matched semantically`;
+      } else {
+        summary = `${newCount} issue(s) created in tracker`;
+      }
+      trackerSpinner.succeed(chalk.green(summary));
+    } catch (err) {
+      trackerSpinner.fail(chalk.red(`Tracker error: ${err.message}`));
+    }
+  }
+
+  // Print summary
+  printSummary({
+    sessionId,
+    steps: steps.length,
+    issues: issues.length,
+    goalAchieved: actuallyPassed,
+    stuck,
+    duration: Date.now() - startTime,
+    reportPath,
+    videoPath,
+    failReason,
+  });
+
+  process.exit(actuallyPassed ? 0 : 1);
+}
+
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < Math.min(str.length, 1000); i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return hash;
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}

package/cli/index.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { runCommand } from './commands/run.js';
+import { initCommand } from './commands/init.js';
+import { reportCommand } from './commands/report.js';
+import { configCommand } from './commands/config.js';
+import { dashboardCommand } from './commands/dashboard.js';
+import { agentCommand } from './commands/agent.js';
+
+const banner = chalk.cyan(`
+  ███████╗██╗  ██╗ ██████╗ ██████╗ ██╗██╗  ██╗
+  ██╔════╝██║ ██╔╝██╔═══██╗██╔══██╗██║╚██╗██╔╝
+  ███████╗█████╔╝ ██║   ██║██████╔╝██║ ╚███╔╝ 
+  ╚════██║██╔═██╗ ██║   ██║██╔═══╝ ██║ ██╔██╗ 
+  ███████║██║  ██╗╚██████╔╝██║     ██║██╔╝ ██╗
+  ╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝
+`);
+
+console.log(banner);
+console.log(chalk.dim('  AI-powered QA agent. Tests your app like a human would.\n'));
+
+program
+  .name('skopix')
+  .description('AI-powered QA testing agent')
+  .version('1.0.0');
+
+program
+  .command('run')
+  .description('Run a QA test session on a URL')
+  .requiredOption('-u, --url <url>', 'Target URL to test')
+  .requiredOption('-g, --goal <goal>', 'Testing goal (e.g. "complete the checkout flow")')
+  .option('-c, --credentials <file>', 'Path to credentials YAML file')
+  .option('-o, --output <dir>', 'Output directory for reports', './skopix-reports')
+  .option('-m, --max-steps <number>', 'Maximum steps the agent will take', '20')
+  .option('--headless', 'Run browser in headless mode', false)
+  .option('--no-video', 'Disable video recording')
+  .option('--provider <provider>', 'LLM provider: gemini | ollama', 'gemini')
+  .option('--model <model>', 'Model name override')
+  .option('--jira', 'Push issues to Jira (requires JIRA_* env vars)')
+  .option('--linear', 'Push issues to Linear (requires LINEAR_API_KEY env var)')
+  .option('--github', 'Push issues to GitHub Issues (requires GITHUB_* env vars)')
+  .option('--test-name <name>', 'Name of the test (for context in created issues)')
+  .option('--suite-name <name>', 'Name of the suite this test belongs to (for context)')
+  .action(runCommand);
+
+program
+  .command('init')
+  .description('Initialise Skopix config in the current directory')
+  .action(initCommand);
+
+program
+  .command('report')
+  .description('Open the latest report in your browser')
+  .option('-d, --dir <dir>', 'Reports directory', './skopix-reports')
+  .action(reportCommand);
+
+program
+  .command('config')
+  .description('View or set configuration values')
+  .option('--set <key=value>', 'Set a config value')
+  .option('--get <key>', 'Get a config value')
+  .option('--list', 'List all config values')
+  .action(configCommand);
+
+program
+  .command('dashboard')
+  .description('Launch the web dashboard')
+  .option('-p, --port <port>', 'Port to run the server on', '9000')
+  .option('-d, --dir <dir>', 'Reports directory', './skopix-reports')
+  .option('-h, --host <host>', 'Host to bind to (default 127.0.0.1; use 0.0.0.0 for team mode)')
+  .option('--team', 'Enable multi-user team mode (requires SQLite)')
+  .option('--no-open', 'Do not auto-open the browser')
+  .action(dashboardCommand);
+
+program
+  .command('agent')
+  .description('Connect this machine as an agent to a shared Skopix server')
+  .requiredOption('-s, --server <url>', 'Skopix server URL (e.g. http://192.168.1.45:9000)')
+  .requiredOption('-k, --key <key>', 'Secret key (same SKOPIX_SECRET_KEY as the server)')
+  .option('-n, --name <name>', 'Agent display name (defaults to hostname)')
+  .action(agentCommand);
+
+program.parse();