qaguardian 1.1.0

package/README.md

@@ -0,0 +1,168 @@
+# QAG CLI - QA Guardian Command Line Interface
+
+Trigger and monitor test suite executions from the command line.
+
+## Installation
+
+```bash
+npm install -g qaguardian
+```
+
+Or use directly with `npx`:
+
+```bash
+npx qaguardian --tags smoke
+```
+
+## Quick Start
+
+```bash
+# Set your API key
+export QAG_API_KEY=your-api-key-here
+
+# Run suites with specific tags
+npx qaguardian --tags auth,login
+
+# Exclude certain tags
+npx qaguardian --tags regression --exclude-tags slow,flaky
+
+# Run all suites
+npx qaguardian --all
+
+# Fire and forget (no polling)
+npx qaguardian --tags smoke --no-wait
+```
+
+## Options
+
+- `--tags <tags>` - Comma-separated tags to match (e.g., "auth,ci,smoke")
+- `--exclude-tags <tags>` - Comma-separated tags to exclude (e.g., "slow,flaky")
+- `--all` - Run all suites (combine with `--exclude-tags` to filter)
+- `--match-mode <mode>` - Tag matching mode: "any" (OR logic, default) or "all" (AND logic)
+- `--no-wait` - Trigger and exit immediately without waiting for results
+- `--webhook-url <url>` - Custom webhook URL for notifications on completion
+- `--notify <service>` - Notify via service: slack, discord, google-chat, or teams
+- `--api-url <url>` - Custom API Gateway URL (default: https://api.qaguardian.com)
+
+## Environment Variables
+
+- `QAG_API_KEY` - (Required) Your QA Guardian API key
+- `QAG_API_URL` - (Optional) API Gateway URL (defaults to https://api.qaguardian.com)
+
+## Examples
+
+### Tag-based execution with wait
+
+```bash
+export QAG_API_KEY=guardians-primary-qag-cbaa125e027b417a
+npx qaguardian --tags auth,ci
+```
+
+### Exclude certain tags
+
+```bash
+npx qaguardian --tags regression --exclude-tags slow,flaky
+```
+
+### Run everything except auth suites
+
+```bash
+npx qaguardian --all --exclude-tags auth
+```
+
+### Fire and forget
+
+```bash
+npx qaguardian --tags smoke --no-wait
+```
+
+### AND logic (all tags required)
+
+```bash
+npx qaguardian --tags auth,login,ui --match-mode all
+```
+
+### Notifications
+
+Receive notifications when tests complete:
+
+```bash
+# Custom webhook URL
+npx qaguardian --tags regression --webhook-url https://my-service.com/webhook
+
+# Slack notification
+npx qaguardian --tags smoke --notify slack
+
+# Discord notification
+npx qaguardian --tags auth --notify discord
+
+# Google Chat notification
+npx qaguardian --tags ci --notify google-chat
+
+# Microsoft Teams notification
+npx qaguardian --tags regression --notify teams
+```
+
+### Local development
+
+```bash
+cd qag-sdk
+npm install
+npm link
+export QAG_API_KEY=your-api-key
+npx qaguardian --tags smoke --api-url http://localhost:8080
+```
+
+## Exit Codes
+
+- `0` - All tests passed
+- `1` - Any test failed or execution failed
+
+## API Key
+
+Get your API key from the QA Guardian dashboard at: https://app.qaguardian.com/settings/api-keys
+
+## Polling Behavior
+
+By default, the CLI polls the API every 30 seconds to check for completion. You can observe:
+
+- Real-time test count updates
+- Pass/fail counts as tests complete
+- Automatic exit with appropriate code when all suites finish
+
+Use `--no-wait` to skip polling and exit immediately after triggering.
+
+## Notifications
+
+The CLI can send notifications when test suites complete. Choose one of:
+
+### Webhook Notifications
+
+Send results to any HTTP endpoint:
+
+```bash
+qag --tags regression --webhook-url https://my-service.com/webhook
+```
+
+The webhook receives a POST request with execution results.
+
+### Platform Notifications
+
+Integrated notification support for popular chat and communication platforms:
+
+- **Slack**: `--notify slack` (requires Slack integration configured in QA Guardian)
+- **Discord**: `--notify discord` (requires Discord integration configured)
+- **Google Chat**: `--notify google-chat` (requires Google Chat integration configured)
+- **Microsoft Teams**: `--notify teams` (requires Teams integration configured)
+
+Example:
+
+```bash
+qag --tags smoke --notify slack
+```
+
+Notifications are sent when all tests complete, with summary of pass/fail counts.
+
+## License
+
+MIT

package/bin/qag.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import('../src/index.js').catch((error) => {
+  console.error('Failed to start QAG CLI:', error.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "qaguardian",
+  "version": "1.1.0",
+  "description": "QA Guardian CLI for triggering and monitoring test suite executions",
+  "keywords": [
+    "testing",
+    "automation",
+    "playwright",
+    "ci-cd"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/qaguardian/qaguardian.git"
+  },
+  "bin": {
+    "qaguardian": "bin/qag.js",
+    "qag": "bin/qag.js"
+  },
+  "main": "src/index.js",
+  "type": "module",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "axios": "^1.6.7",
+    "ora": "^8.0.1",
+    "chalk": "^5.3.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ]
+}

package/src/api-client.js

@@ -0,0 +1,195 @@
+/**
+ * [QAG-CLI] API Client
+ * Handles HTTP communication with QA Guardian API Gateway
+ */
+
+import axios from 'axios';
+
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 1000;
+const RETRY_BACKOFF = 2;
+
+/**
+ * Create axios instance with configuration
+ * @param {string} apiKey - API key for authentication
+ * @param {string} baseUrl - API Gateway base URL
+ * @returns {AxiosInstance} Configured axios instance
+ */
+function createClient(apiKey, baseUrl) {
+  return axios.create({
+    baseURL: baseUrl,
+    headers: {
+      'X-API-Key': apiKey,
+      'Content-Type': 'application/json',
+    },
+    timeout: 30000,
+  });
+}
+
+/**
+ * Retry logic with exponential backoff for transient failures
+ * @param {Function} fn - Async function to retry
+ * @param {number} retries - Number of retries remaining
+ * @param {number} delayMs - Current delay in milliseconds
+ * @returns {Promise<any>} Result of the function
+ */
+async function retryWithBackoff(fn, retries = MAX_RETRIES, delayMs = RETRY_DELAY_MS) {
+  try {
+    return await fn();
+  } catch (error) {
+    const isTransient =
+      error.code === 'ECONNREFUSED' ||
+      error.code === 'ETIMEDOUT' ||
+      error.code === 'ENOTFOUND' ||
+      (error.response && error.response.status >= 500);
+
+    if (isTransient && retries > 0) {
+      await new Promise(resolve => setTimeout(resolve, delayMs));
+      return retryWithBackoff(fn, retries - 1, delayMs * RETRY_BACKOFF);
+    }
+
+    throw error;
+  }
+}
+
+/**
+ * Trigger flow executions by tags or run_all flag.
+ *
+ * Tenant and environment are NOT sent in the request body. The API Gateway
+ * validates the X-API-Key header and injects X-Tenant-Slug / X-Environment-Slug
+ * headers into the forwarded request; the coordinator reads them from there.
+ *
+ * @param {Object} client - Axios client instance
+ * @param {Object} options - Execution options
+ * @param {Array<string>} options.tags - Tags to match
+ * @param {Array<string>} options.excludeTags - Tags to exclude
+ * @param {string} options.tagMatchMode - Tag matching mode ("any" or "all")
+ * @param {boolean} options.runAll - Run all flows for the tenant (skips tags requirement)
+ * @param {string} options.webhookUrl - Optional webhook URL for notifications
+ * @param {string} options.notifyService - Optional notification service (slack, discord, google-chat, teams)
+ * @returns {Promise<Object>} Execution response {triggered_flows, executions, total_triggered}
+ */
+export async function triggerExecution(client, options) {
+  const {
+    tags = [],
+    excludeTags = [],
+    tagMatchMode = 'any',
+    runAll = false,
+    webhookUrl,
+    notifyService,
+  } = options;
+
+  // Validate notification options
+  if (webhookUrl && notifyService) {
+    throw new Error(
+      '[QAG-CLI] Cannot use both --webhook-url and --notify. Choose one.'
+    );
+  }
+
+  if (notifyService) {
+    const validServices = ['slack', 'discord', 'google-chat', 'teams'];
+    if (!validServices.includes(notifyService)) {
+      throw new Error(
+        `[QAG-CLI] Invalid notification service: ${notifyService}. ` +
+        `Valid options: ${validServices.join(', ')}`
+      );
+    }
+  }
+
+  // Require --tags unless --all is set
+  if (!runAll && tags.length === 0) {
+    throw new Error(
+      '[QAG-CLI] Must provide --tags to specify which flows to run, or use --all to run all flows.'
+    );
+  }
+
+  // Build request payload. Tenant/env are omitted — the coordinator reads them
+  // from the X-Tenant-Slug / X-Environment-Slug headers injected by the API Gateway.
+  const payload = {
+    tag_match_mode: tagMatchMode,
+    tags,
+    run_all: runAll,
+  };
+
+  if (excludeTags.length > 0) {
+    payload.exclude_tags = excludeTags;
+  }
+
+  // Add notification config if provided
+  if (webhookUrl || notifyService) {
+    payload.notification_config = {};
+
+    if (webhookUrl) {
+      payload.notification_config.webhook_url = webhookUrl;
+      payload.notification_config.webhook_enabled = true;
+    }
+
+    if (notifyService) {
+      payload.notification_config.notify_service = notifyService;
+      payload.notification_config.service_enabled = true;
+    }
+  }
+
+  try {
+    const response = await retryWithBackoff(() =>
+      client.post('/api/v1/flows/executions', payload)
+    );
+
+    return response.data;
+  } catch (error) {
+    if (error.response?.status === 401) {
+      throw new Error('[QAG-CLI] Authentication failed. Check your QAG_API_KEY.');
+    }
+    if (error.response?.status === 404) {
+      throw new Error('[QAG-CLI] API endpoint not found. Check QAG_API_URL.');
+    }
+    if (error.response?.data?.detail) {
+      const detail = error.response.data.detail;
+      const detailStr = typeof detail === 'string' ? detail : JSON.stringify(detail);
+      throw new Error(`[QAG-CLI] Server error: ${detailStr}`);
+    }
+    throw new Error(
+      `[QAG-CLI] Failed to trigger executions: ${error.message}`
+    );
+  }
+}
+
+/**
+ * Get execution status for a flow run
+ * @param {Object} client - Axios client instance
+ * @param {string} flowRunId - Flow run ID to poll
+ * @returns {Promise<Object>} Execution status object
+ */
+export async function getExecutionStatus(client, flowRunId) {
+  try {
+    const response = await retryWithBackoff(() =>
+      client.get(`/api/v1/flows/executions/${flowRunId}`)
+    );
+
+    return response.data;
+  } catch (error) {
+    if (error.response?.status === 404) {
+      throw new Error(
+        `[QAG-CLI] Flow run ${flowRunId} not found. It may have been cancelled.`
+      );
+    }
+    if (error.response?.data?.detail) {
+      const detail = error.response.data.detail;
+      const detailStr = typeof detail === 'string' ? detail : JSON.stringify(detail);
+      throw new Error(`[QAG-CLI] Server error: ${detailStr}`);
+    }
+    throw new Error(
+      `[QAG-CLI] Failed to get execution status: ${error.message}`
+    );
+  }
+}
+
+/**
+ * Create and return configured API client
+ * @param {string} apiKey - API key for authentication
+ * @param {string} baseUrl - API Gateway base URL
+ * @returns {AxiosInstance} Configured axios instance
+ */
+export function createApiClient(apiKey, baseUrl) {
+  return createClient(apiKey, baseUrl);
+}

package/src/config.js

@@ -0,0 +1,89 @@
+/**
+ * [QAG-CLI] Config module
+ * Validates environment variables and defaults
+ */
+
+const DEFAULT_API_URL = 'https://api.qaguardian.com';
+const DEFAULT_POLL_INTERVAL_MS = 30000; // 30 seconds
+const POLL_TIMEOUT_MS = 3600000; // 1 hour max polling time
+
+/**
+ * Validate and load configuration
+ * @returns {Object} Configuration object
+ * @throws {Error} If required config is missing
+ */
+export function loadConfig() {
+  const apiKey = process.env.QAG_API_KEY;
+
+  if (!apiKey) {
+    throw new Error(
+      '[QAG-CLI] QAG_API_KEY environment variable is required. ' +
+      'Get your API key from https://app.qaguardian.com/settings/api-keys'
+    );
+  }
+
+  return {
+    apiKey,
+    apiUrl: process.env.QAG_API_URL || DEFAULT_API_URL,
+    pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
+    pollTimeoutMs: POLL_TIMEOUT_MS,
+  };
+}
+
+/**
+ * Parse comma-separated tag string into array
+ * @param {string} tagString - Comma-separated tags (e.g. "auth,ci,smoke")
+ * @returns {Array<string>} Array of trimmed tags
+ */
+export function parseTags(tagString) {
+  if (!tagString) return [];
+  return tagString
+    .split(',')
+    .map(tag => tag.trim())
+    .filter(tag => tag.length > 0);
+}
+
+/**
+ * Parse API key to extract tenant and environment slugs
+ * Format: {tenant_slug}-{environment_slug}-qag-{hash}
+ * Example: guardians-primary-qag-cbaa125e027b417a
+ * @param {string} apiKey - API key to parse
+ * @returns {{tenant_slug: string, environment_slug: string}|null}
+ */
+export function parseApiKey(apiKey) {
+  if (!apiKey) return null;
+
+  // Split on '-qag-' to isolate the hash suffix
+  const parts = apiKey.split('-qag-');
+  if (parts.length !== 2) return null;
+
+  const hash = parts[1];
+  if (!/^[a-f0-9]+$/.test(hash)) return null;
+
+  // The prefix is '{tenant_slug}-{environment_slug}'
+  // Use the last hyphen to split, so multi-segment tenant slugs work
+  const prefix = parts[0];
+  const lastDash = prefix.lastIndexOf('-');
+  if (lastDash === -1) return null;
+
+  return {
+    tenant_slug: prefix.substring(0, lastDash),
+    environment_slug: prefix.substring(lastDash + 1),
+  };
+}
+
+/**
+ * Validate tag matching mode
+ * @param {string} mode - Matching mode ("any" or "all")
+ * @returns {string} Validated mode
+ * @throws {Error} If mode is invalid
+ */
+export function validateTagMatchMode(mode) {
+  const valid = ['any', 'all'];
+  if (!valid.includes(mode)) {
+    throw new Error(
+      `[QAG-CLI] Invalid tag match mode: ${mode}. Must be "any" (OR) or "all" (AND).`
+    );
+  }
+  return mode;
+}

package/src/index.js

@@ -0,0 +1,189 @@
+/**
+ * [QAG-CLI] Main CLI Entry Point
+ * Command-line interface for triggering and monitoring QA Guardian test executions
+ */
+
+import { createRequire } from 'module';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { loadConfig, parseTags, validateTagMatchMode, parseApiKey } from './config.js';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+import { createApiClient, triggerExecution } from './api-client.js';
+import { pollUntilComplete } from './poller.js';
+
+const program = new Command();
+
+program
+  .name('qag')
+  .description('QA Guardian CLI - Trigger and monitor test suite executions')
+  .version(version)
+  .usage('[options]')
+  .option(
+    '--tags <tags>',
+    'Comma-separated tags to match (e.g., "auth,ci,smoke")'
+  )
+  .option(
+    '--exclude-tags <tags>',
+    'Comma-separated tags to exclude (e.g., "slow,flaky")'
+  )
+  .option(
+    '--all',
+    'Run all flows (combine with --exclude-tags to filter)'
+  )
+  .option(
+    '--match-mode <mode>',
+    'Tag matching mode: "any" (OR logic, default) or "all" (AND logic)',
+    'any'
+  )
+  .option(
+    '--no-wait',
+    'Trigger and exit immediately without waiting for results'
+  )
+  .option(
+    '--webhook-url <url>',
+    'Custom webhook URL for completion notifications'
+  )
+  .option(
+    '--notify <service>',
+    'Notify via service: slack, discord, google-chat, or teams'
+  )
+  .option(
+    '--api-url <url>',
+    'Custom API Gateway URL (default: https://api.qaguardian.com)',
+    'https://api.qaguardian.com'
+  )
+  .action(runCLI);
+
+program.parse();
+
+/**
+ * Main CLI execution handler
+ * @param {Object} options - Parsed CLI options
+ */
+async function runCLI(options) {
+  try {
+    // Load and validate configuration
+    const config = loadConfig();
+    const client = createApiClient(config.apiKey, options.apiUrl);
+
+    // Parse and validate options
+    const tags = parseTags(options.tags || '');
+    const excludeTags = parseTags(options.excludeTags || '');
+    const tagMatchMode = validateTagMatchMode(options.matchMode);
+    const runAll = options.all || false;
+    const wait = options.wait; // true by default, false with --no-wait
+    const apiUrl = options.apiUrl;
+
+    // Extract tenant and environment from API key
+    const apiKeyInfo = parseApiKey(config.apiKey);
+    if (!apiKeyInfo) {
+      throw new Error(
+        '[QAG-CLI] Invalid API key format. Expected: {tenant_slug}-{environment_slug}-qag-{hash}'
+      );
+    }
+
+    const { tenant_slug, environment_slug } = apiKeyInfo;
+
+    console.log(
+      chalk.blue('[QAG-CLI]'),
+      'Triggering flow executions...'
+    );
+
+    if (runAll && excludeTags.length > 0) {
+      console.log(chalk.gray('  Excluding tags:'), excludeTags.join(', '));
+    } else if (tags.length > 0) {
+      console.log(chalk.gray('  Tags:'), tags.join(', '));
+      if (excludeTags.length > 0) {
+        console.log(chalk.gray('  Excluding:'), excludeTags.join(', '));
+      }
+    }
+
+    if (options.webhookUrl) {
+      console.log(chalk.gray('  Webhook:'), options.webhookUrl);
+    }
+
+    if (options.notify) {
+      console.log(chalk.gray('  Notify via:'), options.notify);
+    }
+
+    // Validate that we have tags
+    if (!runAll && tags.length === 0) {
+      throw new Error('[QAG-CLI] Must provide --tags to specify which flows to run');
+    }
+
+    // Trigger execution
+    const response = await triggerExecution(client, {
+      tags,
+      excludeTags,
+      tagMatchMode,
+      runAll,
+      tenantSlug: tenant_slug,
+      environmentName: environment_slug,
+      webhookUrl: options.webhookUrl,
+      notifyService: options.notify,
+    });
+
+    const { triggered_flows: flowRunIds, executions, total_triggered: totalTriggered } = response;
+
+    if (!flowRunIds || flowRunIds.length === 0) {
+      console.log(chalk.yellow('⚠ No flows matched the specified criteria'));
+      process.exit(0);
+    }
+
+    console.log(
+      chalk.green('✓'),
+      `Triggered ${totalTriggered} flow run(s):`,
+      flowRunIds.join(', ')
+    );
+
+    // If --no-wait, exit immediately
+    if (!wait) {
+      console.log(
+        chalk.blue('[QAG-CLI]'),
+        'Not waiting for completion (--no-wait flag set)'
+      );
+      process.exit(0);
+    }
+
+    // Poll for completion
+    console.log(chalk.blue('[QAG-CLI]') + ' Polling for results (30s intervals)...');
+    const result = await pollUntilComplete(client, flowRunIds, {
+      pollIntervalMs: 30000,
+      pollTimeoutMs: 3600000,
+    });
+
+    // Print final summary
+    const { summary } = result;
+    console.log();
+    console.log(chalk.blue('═══════════════════════════════════'));
+    console.log(chalk.blue('[QAG-CLI] Execution Summary:'));
+    console.log(chalk.blue('═══════════════════════════════════'));
+    console.log(`  Flow Runs: ${summary.flowRuns}`);
+    console.log(`  Total Tests: ${summary.totalTests}`);
+    console.log(
+      `  ${chalk.green('Passed:')} ${summary.passed}`
+    );
+    console.log(
+      `  ${chalk.red('Failed:')} ${summary.failed}`
+    );
+    console.log(chalk.blue('═══════════════════════════════════'));
+
+    // Exit with appropriate code
+    if (summary.hasFailures) {
+      console.log(
+        chalk.red('✗ Tests completed with failures')
+      );
+      process.exit(1);
+    } else {
+      console.log(
+        chalk.green('✓ All tests passed!')
+      );
+      process.exit(0);
+    }
+  } catch (error) {
+    console.error(chalk.red(error.message || 'Unknown error'));
+    process.exit(1);
+  }
+}

package/src/poller.js

@@ -0,0 +1,154 @@
+/**
+ * [QAG-CLI] Polling Module
+ * Handles real-time polling of flow executions with progress display
+ */
+
+import ora from 'ora';
+import { getExecutionStatus } from './api-client.js';
+
+/**
+ * Poll flow runs until completion
+ * @param {Object} client - Axios client instance
+ * @param {Array<string>} flowRunIds - Flow run IDs to monitor
+ * @param {Object} config - Configuration {pollIntervalMs, pollTimeoutMs}
+ * @returns {Promise<Object>} Final execution results
+ */
+export async function pollUntilComplete(client, flowRunIds, config) {
+  if (!flowRunIds || flowRunIds.length === 0) {
+    throw new Error('[QAG-CLI] No flow runs to poll');
+  }
+
+  const { pollIntervalMs = 30000, pollTimeoutMs = 3600000 } = config;
+
+  const spinner = ora({
+    text: `[QAG-CLI] Polling ${flowRunIds.length} flow run(s)...`,
+    prefixText: '',
+    spinner: 'dots',
+  }).start();
+
+  const startTime = Date.now();
+  const statuses = new Map(); // Track individual run statuses
+
+  try {
+    while (true) {
+      // Check for timeout
+      if (Date.now() - startTime > pollTimeoutMs) {
+        spinner.fail('[QAG-CLI] Polling timeout reached (1 hour)');
+        return createFailureResult(statuses);
+      }
+
+      // Poll all flow runs in parallel
+      const pollPromises = flowRunIds.map(id =>
+        getExecutionStatus(client, id)
+          .then(status => ({ id, status, error: null }))
+          .catch(error => ({ id, status: null, error }))
+      );
+
+      const results = await Promise.all(pollPromises);
+
+      // Update statuses map
+      let allComplete = true;
+      let totalTests = 0;
+      let completedTests = 0;
+      let passedTests = 0;
+      let failedTests = 0;
+
+      for (const result of results) {
+        if (result.error) {
+          statuses.set(result.id, { status: 'error', error: result.error.message });
+          allComplete = false;
+          continue;
+        }
+
+        const { status } = result.status;
+        statuses.set(result.id, result.status);
+
+        // Aggregate stats
+        totalTests += result.status.total_tests || 0;
+        completedTests += result.status.completed_tests || 0;
+        failedTests += result.status.failed_tests || 0;
+
+        if (status === 'starting' || status === 'running' || status === 'pending') {
+          allComplete = false;
+        }
+      }
+
+      // Calculate passed from completed and failed
+      passedTests = completedTests - failedTests;
+
+      // Update spinner text with progress
+      const progressText = `Running... (${completedTests}/${totalTests} tests completed, ${failedTests} failed)`;
+      spinner.text = progressText;
+
+      // Check if all runs are complete
+      if (allComplete) {
+        break;
+      }
+
+      // Wait before next poll
+      await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+    }
+
+    spinner.succeed('[QAG-CLI] All flow runs completed');
+    return createSuccessResult(statuses);
+  } catch (error) {
+    spinner.fail(`[QAG-CLI] Error during polling: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Create success result object
+ * @param {Map} statuses - Flow run statuses
+ * @returns {Object} Result with exit code and summary
+ */
+function createSuccessResult(statuses) {
+  let hasFailures = false;
+  let totalTests = 0;
+  let totalPassed = 0;
+  let totalFailed = 0;
+
+  for (const [id, status] of statuses.entries()) {
+    if (status.error) {
+      hasFailures = true;
+      continue;
+    }
+
+    totalTests += status.total_tests || 0;
+    totalPassed += (status.total_tests || 0) - (status.failed_tests || 0);
+    totalFailed += status.failed_tests || 0;
+
+    if (status.status === 'failed' || status.failed_tests > 0) {
+      hasFailures = true;
+    }
+  }
+
+  return {
+    exitCode: hasFailures ? 1 : 0,
+    summary: {
+      totalTests,
+      passed: totalPassed,
+      failed: totalFailed,
+      flowRuns: statuses.size,
+      hasFailures,
+    },
+  };
+}
+
+/**
+ * Create failure result object
+ * @param {Map} statuses - Flow run statuses
+ * @returns {Object} Result with exit code and summary
+ */
+function createFailureResult(statuses) {
+  return {
+    exitCode: 1,
+    summary: {
+      totalTests: 0,
+      passed: 0,
+      failed: 0,
+      flowRuns: statuses.size,
+      hasFailures: true,
+    },
+  };
+}