norn-cli 1.6.0 → 1.6.2

package/out/cli.js

@@ -1,989 +0,0 @@
-"use strict";
-/**
- * Norn CLI - Command-line interface for running .norn files
- *
- * Features:
- * - Human-readable output with color coding
- * - Verbose mode for detailed request/response info
- * - Automatic sensitive data redaction
- * - JUnit XML output for CI/CD
- * - HTML report generation
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __importStar(require("fs"));
-const fsPromises = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-const parser_1 = require("./parser");
-const httpClient_1 = require("./httpClient");
-const sequenceRunner_1 = require("./sequenceRunner");
-const nornapiParser_1 = require("./nornapiParser");
-// CLI modules
-const colors_1 = require("./cli/colors");
-const redaction_1 = require("./cli/redaction");
-const summary_1 = require("./cli/formatters/summary");
-const response_1 = require("./cli/formatters/response");
-const junit_1 = require("./cli/reporters/junit");
-const html_1 = require("./cli/reporters/html");
-const ENV_FILENAME = '.nornenv';
-function getEnvSearchStartDirectory(targetPath) {
-    const resolvedPath = path.resolve(targetPath);
-    try {
-        const stats = fs.statSync(resolvedPath);
-        return stats.isDirectory() ? resolvedPath : path.dirname(resolvedPath);
-    }
-    catch {
-        return path.dirname(resolvedPath);
-    }
-}
-/**
- * Finds .nornenv file relative to a specific file path (for CLI usage)
- */
-function findEnvFileFromPath(filePath) {
-    let dir = getEnvSearchStartDirectory(filePath);
-    while (true) {
-        const envPath = path.join(dir, ENV_FILENAME);
-        if (fs.existsSync(envPath)) {
-            return envPath;
-        }
-        const parentDir = path.dirname(dir);
-        if (parentDir === dir) {
-            break;
-        }
-        dir = parentDir;
-    }
-    return undefined;
-}
-/**
- * Parses the .nornenv file content (with secret support)
- */
-function parseEnvFile(content) {
-    const lines = content.split('\n');
-    const config = {
-        common: {},
-        environments: [],
-        secretNames: new Set(),
-        secretValues: new Map()
-    };
-    let currentEnv = null;
-    const envRegex = /^\[env:([a-zA-Z_][a-zA-Z0-9_-]*)\]$/;
-    const varRegex = /^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/;
-    const secretRegex = /^secret\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Skip empty lines and comments
-        if (!trimmed || trimmed.startsWith('#')) {
-            continue;
-        }
-        // Check for environment section
-        const envMatch = trimmed.match(envRegex);
-        if (envMatch) {
-            currentEnv = {
-                name: envMatch[1],
-                variables: {}
-            };
-            config.environments.push(currentEnv);
-            continue;
-        }
-        // Check for secret declaration
-        const secretMatch = trimmed.match(secretRegex);
-        if (secretMatch) {
-            const varName = secretMatch[1];
-            const varValue = secretMatch[2].trim();
-            config.secretNames.add(varName);
-            config.secretValues.set(varName, varValue);
-            if (currentEnv) {
-                currentEnv.variables[varName] = varValue;
-            }
-            else {
-                config.common[varName] = varValue;
-            }
-            continue;
-        }
-        // Check for variable declaration
-        const varMatch = trimmed.match(varRegex);
-        if (varMatch) {
-            const varName = varMatch[1];
-            const varValue = varMatch[2].trim();
-            if (currentEnv) {
-                currentEnv.variables[varName] = varValue;
-            }
-            else {
-                config.common[varName] = varValue;
-            }
-        }
-    }
-    return config;
-}
-function resolveEnvironmentForPath(targetPath, selectedEnv) {
-    const envFilePath = findEnvFileFromPath(targetPath);
-    if (!envFilePath) {
-        return {
-            variables: {},
-            secretNames: new Set(),
-            secretValues: new Map(),
-            availableEnvironments: []
-        };
-    }
-    const envContent = fs.readFileSync(envFilePath, 'utf-8');
-    const envConfig = parseEnvFile(envContent);
-    const variables = { ...envConfig.common };
-    const secretNames = new Set(envConfig.secretNames);
-    const secretValues = new Map(envConfig.secretValues);
-    const availableEnvironments = envConfig.environments.map(e => e.name);
-    if (selectedEnv) {
-        const targetEnv = envConfig.environments.find(e => e.name === selectedEnv);
-        if (!targetEnv) {
-            return {
-                envFilePath,
-                variables,
-                secretNames,
-                secretValues,
-                availableEnvironments,
-                envNotFound: selectedEnv
-            };
-        }
-        Object.assign(variables, targetEnv.variables);
-        for (const [name, value] of Object.entries(targetEnv.variables)) {
-            if (secretNames.has(name)) {
-                secretValues.set(name, value);
-            }
-        }
-    }
-    return {
-        envFilePath,
-        variables,
-        secretNames,
-        secretValues,
-        availableEnvironments
-    };
-}
-function mergeSecrets(targetNames, targetValues, sourceNames, sourceValues) {
-    for (const name of sourceNames) {
-        targetNames.add(name);
-    }
-    for (const [name, value] of sourceValues) {
-        targetValues.set(name, value);
-    }
-}
-/**
- * Generate a timestamp string for report filenames
- * Format: YYYY-MM-DD-HHmmss
- */
-function generateTimestamp() {
-    const now = new Date();
-    const year = now.getFullYear();
-    const month = String(now.getMonth() + 1).padStart(2, '0');
-    const day = String(now.getDate()).padStart(2, '0');
-    const hours = String(now.getHours()).padStart(2, '0');
-    const minutes = String(now.getMinutes()).padStart(2, '0');
-    const seconds = String(now.getSeconds()).padStart(2, '0');
-    return `${year}-${month}-${day}-${hours}${minutes}${seconds}`;
-}
-/**
- * Generate output paths for reports when using --output-dir
- */
-function generateReportPaths(outputDir, inputFile, timestamp) {
-    const baseName = path.basename(inputFile, path.extname(inputFile));
-    return {
-        junitPath: path.join(outputDir, `${baseName}-${timestamp}-results.xml`),
-        htmlPath: path.join(outputDir, `${baseName}-${timestamp}-report.html`)
-    };
-}
-function parseArgs(args) {
-    const options = {
-        file: '',
-        output: 'pretty',
-        verbose: false,
-        failOnError: true,
-        noRedact: false,
-        tagFilters: [],
-        tagsFilter: [],
-    };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--json' || arg === '-j') {
-            options.output = 'json';
-        }
-        else if (arg === '--verbose' || arg === '-v') {
-            options.verbose = true;
-        }
-        else if (arg === '--sequence' || arg === '-s') {
-            options.sequence = args[++i];
-        }
-        else if (arg === '--request' || arg === '-r') {
-            options.request = args[++i];
-        }
-        else if (arg === '--env' || arg === '-e') {
-            options.env = args[++i];
-        }
-        else if (arg === '--timeout' || arg === '-t') {
-            options.timeout = parseInt(args[++i], 10) * 1000;
-        }
-        else if (arg === '--no-fail') {
-            options.failOnError = false;
-        }
-        else if (arg === '--no-redact') {
-            options.noRedact = true;
-        }
-        else if (arg === '--junit') {
-            options.junitOutput = args[++i];
-        }
-        else if (arg === '--html') {
-            options.htmlOutput = args[++i];
-        }
-        else if (arg === '--output-dir' || arg === '-o') {
-            options.outputDir = args[++i];
-        }
-        else if (arg === '--tag') {
-            const tagStr = args[++i];
-            if (tagStr) {
-                options.tagFilters.push((0, sequenceRunner_1.parseTagFilter)(tagStr));
-            }
-        }
-        else if (arg === '--tags') {
-            const tagsStr = args[++i];
-            if (tagsStr) {
-                const tags = tagsStr.split(',').map(t => t.trim()).filter(t => t);
-                options.tagsFilter.push(...tags.map(t => (0, sequenceRunner_1.parseTagFilter)(t)));
-            }
-        }
-        else if (arg === '--help' || arg === '-h') {
-            printHelp();
-            process.exit(0);
-        }
-        else if (!arg.startsWith('-')) {
-            options.file = arg;
-        }
-    }
-    return options;
-}
-function printHelp() {
-    console.log(`
-Norn CLI - Run HTTP requests and test sequences from .norn files
-
-Usage: norn <file.norn|directory> [options]
-
-  When given a directory, recursively discovers and runs all test sequences
-  from .norn files within that directory and subdirectories.
-
-Options:
-  -s, --sequence <name>  Run a specific sequence by name (single file only)
-  -r, --request <name>   Run a specific named request (single file only)
-  -e, --env <name>       Use environment from .nornenv (e.g., dev, prod)
-  -t, --timeout <sec>    Request timeout in seconds (default: no timeout)
-  -j, --json             Output results as JSON (for CI/CD)
-  -v, --verbose          Show detailed output (headers, request/response bodies)
-  --no-fail              Don't exit with error code on failed requests
-  --no-redact            Disable automatic redaction of sensitive data
-  --junit <file>         Generate JUnit XML report (explicit path)
-  --html <file>          Generate HTML report (explicit path)
-  -o, --output-dir <dir> Output directory for reports (auto-generates timestamped files)
-  --tag <filter>         Filter sequences by tag (AND logic, can be repeated)
-  --tags <filters>       Filter sequences by tags (OR logic, comma-separated)
-  -h, --help             Show this help message
-
-Report Generation:
-  Use --output-dir for auto-generated timestamped filenames:
-    norn tests.norn --output-dir ./reports
-    # Creates: ./reports/tests-2026-02-01-120000-results.xml
-    #          ./reports/tests-2026-02-01-120000-report.html
-  
-  Or use explicit paths with --junit and --html:
-    norn tests.norn --junit results.xml --html report.html
-
-Output Behavior:
-  By default, only errors and failures show full details.
-  Use -v/--verbose to see all request/response details.
-
-Sensitive Data:
-  Authorization headers, tokens, and secrets are automatically redacted.
-  Use 'secret' keyword in .nornenv to mark variables for redaction:
-    secret apiKey = my-secret-key
-  Use --no-redact to disable redaction for debugging.
-
-Tag Filtering:
-  Tags are decorators on sequences: @smoke, @team(CustomerExp)
-  
-  --tag smoke                  Run sequences with @smoke tag
-  --tag smoke --tag auth       Run sequences with BOTH @smoke AND @auth tags
-  --tags smoke,auth            Run sequences with @smoke OR @auth tag
-  --tag team(CustomerExp)      Run sequences with @team(CustomerExp) exact match
-
-Examples:
-  norn api-tests.norn                       # Run all test sequences in file
-  norn tests/                               # Run all tests in directory (recursive)
-  norn tests/Regression/ -e prelive         # Run regression suite with environment
-  norn api-tests.norn -s auth               # Run 'auth' sequence by name
-  norn api-tests.norn -r LoginRequest       # Run 'LoginRequest' named request
-  norn api-tests.norn -e production         # Use 'production' environment
-  norn api-tests.norn -j                    # JSON output for CI/CD
-  norn api-tests.norn -v                    # Verbose output with all details
-  norn tests/ -o ./reports                  # Generate reports for all tests
-  norn api-tests.norn --junit results.xml   # Generate JUnit report (explicit)
-  norn api-tests.norn --html report.html    # Generate HTML report (explicit)
-  norn api-tests.norn --no-redact           # Show all data (no redaction)
-`);
-}
-async function runSingleRequest(fileContent, variables, cookieJar, apiDefinitions) {
-    const lines = fileContent.split('\n');
-    const requestLines = [];
-    let foundRequestLine = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!foundRequestLine) {
-            if (!trimmed || trimmed.startsWith('import ') || trimmed.startsWith('#')) {
-                continue;
-            }
-        }
-        if (!foundRequestLine && /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i.test(trimmed)) {
-            foundRequestLine = true;
-        }
-        if (foundRequestLine) {
-            requestLines.push(line);
-        }
-    }
-    const requestContent = requestLines.join('\n').trim();
-    if (apiDefinitions &&
-        apiDefinitions.endpoints.length > 0 &&
-        (0, nornapiParser_1.isApiRequestLine)(requestContent, apiDefinitions.endpoints)) {
-        const apiRequest = (0, nornapiParser_1.parseApiRequest)(requestContent, apiDefinitions.endpoints, apiDefinitions.headerGroups);
-        if (apiRequest) {
-            const endpoint = (0, nornapiParser_1.getEndpoint)({ headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints }, apiRequest.endpointName);
-            if (endpoint) {
-                let resolvedPath = endpoint.path;
-                for (const [key, value] of Object.entries(variables)) {
-                    resolvedPath = resolvedPath.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), String(value));
-                }
-                for (const [paramName, paramValue] of Object.entries(apiRequest.params)) {
-                    let resolvedValue = paramValue;
-                    if (variables[paramValue] !== undefined) {
-                        resolvedValue = String(variables[paramValue]);
-                    }
-                    else if (paramValue.startsWith('{{') && paramValue.endsWith('}}')) {
-                        const varName = paramValue.slice(2, -2);
-                        if (variables[varName] !== undefined) {
-                            resolvedValue = String(variables[varName]);
-                        }
-                    }
-                    resolvedPath = resolvedPath.replace(`{${paramName}}`, resolvedValue);
-                }
-                const combinedHeaders = {};
-                for (const groupName of apiRequest.headerGroupNames) {
-                    const group = apiDefinitions.headerGroups.find(hg => hg.name === groupName);
-                    if (group) {
-                        const resolvedHeaders = (0, nornapiParser_1.resolveHeaderValues)(group, variables);
-                        Object.assign(combinedHeaders, resolvedHeaders);
-                    }
-                }
-                // Add inline headers (these take precedence over header groups)
-                for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
-                    // Resolve variable references in header values
-                    let resolved = headerValue;
-                    resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
-                        return variables[varName] !== undefined ? String(variables[varName]) : `{{${varName}}}`;
-                    });
-                    combinedHeaders[headerName] = resolved;
-                }
-                const parsed = {
-                    method: apiRequest.method,
-                    url: resolvedPath,
-                    headers: combinedHeaders,
-                    body: apiRequest.body
-                };
-                return await (0, httpClient_1.sendRequestWithJar)(parsed, cookieJar);
-            }
-        }
-    }
-    // Regular HTTP request - parse and apply header groups
-    let parsed = (0, parser_1.parserHttpRequest)(requestContent, variables);
-    // Check for header group names in the request text
-    if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
-        const headerGroupNames = apiDefinitions.headerGroups.map(hg => hg.name);
-        const foundGroups = [];
-        for (const line of requestLines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('var ')) {
-                continue;
-            }
-            // Check if this is the HTTP method line - look for header groups at the end
-            const methodMatch = trimmed.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
-            if (methodMatch) {
-                const afterMethod = methodMatch[2];
-                const tokens = afterMethod.split(/\s+/);
-                // Scan from the end to find header groups
-                for (let i = tokens.length - 1; i >= 0; i--) {
-                    if (headerGroupNames.includes(tokens[i])) {
-                        foundGroups.push(tokens[i]);
-                    }
-                    else {
-                        break;
-                    }
-                }
-                continue;
-            }
-            // Skip lines that look like headers (Name: Value)
-            if (/^[A-Za-z0-9\-_]+\s*:\s*.+$/.test(trimmed)) {
-                continue;
-            }
-            // Check if this line contains header group names (can be multiple space-separated)
-            const potentialGroups = trimmed.split(/\s+/);
-            for (const groupName of potentialGroups) {
-                if (headerGroupNames.includes(groupName)) {
-                    foundGroups.push(groupName);
-                }
-            }
-        }
-        // Collect headers from all found groups and strip from URL
-        for (const groupName of foundGroups) {
-            const group = apiDefinitions.headerGroups.find(hg => hg.name === groupName);
-            if (group) {
-                const resolvedHeaders = (0, nornapiParser_1.resolveHeaderValues)(group, variables);
-                parsed.headers = { ...resolvedHeaders, ...parsed.headers };
-            }
-            // Strip from URL
-            const endPattern = new RegExp(`\\s+${groupName}$`);
-            parsed.url = parsed.url.replace(endPattern, '');
-        }
-        parsed.url = parsed.url.trim();
-    }
-    return await (0, httpClient_1.sendRequestWithJar)(parsed, cookieJar);
-}
-/**
- * Recursively discover all .norn files in a directory
- */
-function discoverNornFiles(dirPath) {
-    const files = [];
-    function walkDir(currentPath) {
-        const entries = fs.readdirSync(currentPath, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(currentPath, entry.name);
-            if (entry.isDirectory()) {
-                // Skip common non-test directories
-                if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
-                    walkDir(fullPath);
-                }
-            }
-            else if (entry.isFile() && entry.name.endsWith('.norn')) {
-                files.push(fullPath);
-            }
-        }
-    }
-    walkDir(dirPath);
-    return files.sort(); // Sort for consistent ordering
-}
-/**
- * Count test sequences in a file without running them
- */
-function countTestSequences(fileContent, tagFilterOptions) {
-    const allSequences = (0, sequenceRunner_1.extractSequences)(fileContent);
-    const testSequences = allSequences.filter(seq => seq.isTest);
-    const filtered = tagFilterOptions && tagFilterOptions.filters.length > 0
-        ? testSequences.filter(seq => (0, sequenceRunner_1.sequenceMatchesTags)(seq, tagFilterOptions)).length
-        : testSequences.length;
-    return { total: testSequences.length, filtered };
-}
-/**
- * Loads theory data from an external JSON file
- */
-async function loadTheoryFile(theoryPath, workingDir) {
-    const absolutePath = path.resolve(workingDir, theoryPath);
-    const content = await fsPromises.readFile(absolutePath, 'utf-8');
-    return JSON.parse(content);
-}
-/**
- * Formats a test case label from parameter names and values
- */
-function formatCaseLabel(params) {
-    const parts = Object.entries(params).map(([key, value]) => {
-        if (typeof value === 'string') {
-            return `${key}="${value}"`;
-        }
-        return `${key}=${value}`;
-    });
-    return `[${parts.join(', ')}]`;
-}
-async function runAllSequences(fileContent, variables, cookieJar, workingDir, apiDefinitions, tagFilterOptions, sequenceSources) {
-    const allSequences = (0, sequenceRunner_1.extractSequences)(fileContent);
-    const results = [];
-    // First filter to only test sequences (isTest === true)
-    const testSequences = allSequences.filter(seq => seq.isTest);
-    // Then apply tag filters if present
-    const sequences = tagFilterOptions && tagFilterOptions.filters.length > 0
-        ? testSequences.filter(seq => (0, sequenceRunner_1.sequenceMatchesTags)(seq, tagFilterOptions))
-        : testSequences;
-    for (const seq of sequences) {
-        // Check if this is a parameterized test
-        let theoryData = seq.theoryData;
-        // If we have a @theory source file, load it
-        if (theoryData?.source && theoryData.cases.length === 0) {
-            try {
-                const cases = await loadTheoryFile(theoryData.source, workingDir);
-                theoryData = { ...theoryData, cases };
-            }
-            catch (error) {
-                // Report error as a failed result
-                const errorResult = {
-                    name: seq.name,
-                    success: false,
-                    responses: [],
-                    scriptResults: [],
-                    assertionResults: [],
-                    steps: [],
-                    errors: [`Failed to load theory file '${theoryData.source}': ${error instanceof Error ? error.message : String(error)}`],
-                    duration: 0
-                };
-                results.push(errorResult);
-                continue;
-            }
-        }
-        // If this has theory data with cases, run each case separately
-        if (theoryData && theoryData.cases.length > 0) {
-            for (let caseIdx = 0; caseIdx < theoryData.cases.length; caseIdx++) {
-                const caseParams = theoryData.cases[caseIdx];
-                const caseLabel = formatCaseLabel(caseParams);
-                // Convert case params to string args
-                const caseArgs = {};
-                for (const [key, value] of Object.entries(caseParams)) {
-                    caseArgs[key] = String(value);
-                }
-                const result = await (0, sequenceRunner_1.runSequenceWithJar)(seq.content, variables, cookieJar, workingDir, fileContent, undefined, undefined, caseArgs, apiDefinitions, tagFilterOptions, sequenceSources);
-                result.name = `${seq.name}${caseLabel}`;
-                results.push(result);
-            }
-        }
-        else {
-            // Regular test sequence (no parameterization)
-            const defaultArgs = {};
-            if (seq.parameters) {
-                for (const param of seq.parameters) {
-                    if (param.defaultValue !== undefined) {
-                        defaultArgs[param.name] = param.defaultValue;
-                    }
-                }
-            }
-            const result = await (0, sequenceRunner_1.runSequenceWithJar)(seq.content, variables, cookieJar, workingDir, fileContent, undefined, undefined, defaultArgs, apiDefinitions, tagFilterOptions, sequenceSources);
-            result.name = seq.name;
-            results.push(result);
-        }
-    }
-    return results;
-}
-async function main() {
-    const args = process.argv.slice(2);
-    if (args.length === 0) {
-        printHelp();
-        process.exit(1);
-    }
-    const options = parseArgs(args);
-    if (!options.file) {
-        console.error('Error: No input file or directory specified');
-        process.exit(1);
-    }
-    // Initialize colors (async due to chalk v5 ESM)
-    const colors = await (0, colors_1.initColors)();
-    const inputPath = path.resolve(options.file);
-    if (!fs.existsSync(inputPath)) {
-        console.error(`Error: Path not found: ${inputPath}`);
-        process.exit(1);
-    }
-    const isDirectory = fs.statSync(inputPath).isDirectory();
-    // Discover files to run
-    let filesToRun;
-    if (isDirectory) {
-        filesToRun = discoverNornFiles(inputPath);
-        if (filesToRun.length === 0) {
-            console.log(colors.info(`No .norn files found in ${inputPath}`));
-            process.exit(0);
-        }
-        if (options.verbose) {
-            console.log(colors.info(`Discovered ${filesToRun.length} .norn file(s) in ${inputPath}`));
-        }
-    }
-    else {
-        filesToRun = [inputPath];
-    }
-    // For directory mode, we aggregate results across all files
-    const allResults = [];
-    const allErrors = [];
-    let overallSuccess = true;
-    const startTime = Date.now();
-    const combinedSecretNames = new Set();
-    const combinedSecretValues = new Map();
-    let tagFilterOptions = undefined;
-    if (options.tagFilters.length > 0) {
-        tagFilterOptions = {
-            filters: options.tagFilters,
-            mode: 'and'
-        };
-    }
-    else if (options.tagsFilter.length > 0) {
-        tagFilterOptions = {
-            filters: options.tagsFilter,
-            mode: 'or'
-        };
-    }
-    // If running a specific sequence or request, only works with single file
-    if ((options.sequence || options.request) && isDirectory) {
-        console.error('Error: --sequence and --request flags require a specific file, not a directory');
-        process.exit(1);
-    }
-    // Single file mode with specific sequence/request
-    if (options.sequence || options.request) {
-        const filePath = filesToRun[0];
-        const resolvedEnv = resolveEnvironmentForPath(filePath, options.env);
-        if (resolvedEnv.envNotFound) {
-            console.error(`Error: Environment '${resolvedEnv.envNotFound}' not found in .nornenv`);
-            console.error(`Available environments: ${resolvedEnv.availableEnvironments.join(', ') || 'none'}`);
-            process.exit(1);
-        }
-        if (!resolvedEnv.envFilePath && options.env) {
-            console.error(colors.warning(`Warning: --env specified but no .nornenv file found`));
-        }
-        else if (resolvedEnv.envFilePath && options.env && options.verbose) {
-            console.log(colors.info(`Using environment: ${options.env}`));
-        }
-        mergeSecrets(combinedSecretNames, combinedSecretValues, resolvedEnv.secretNames, resolvedEnv.secretValues);
-        const redaction = (0, redaction_1.createRedactionOptions)(combinedSecretNames, combinedSecretValues, !options.noRedact);
-        const fileContent = fs.readFileSync(filePath, 'utf-8');
-        const fileVariables = (0, parser_1.extractFileLevelVariables)(fileContent);
-        const variables = { ...resolvedEnv.variables, ...fileVariables };
-        const cookieJar = (0, httpClient_1.createCookieJar)();
-        const workingDir = path.dirname(filePath);
-        const importResult = await (0, parser_1.resolveImports)(fileContent, workingDir, async (importPath) => fsPromises.readFile(importPath, 'utf-8'));
-        // Check for duplicate definition errors which should block execution
-        const duplicateErrors = importResult.errors.filter(err => err.error.includes('Duplicate header group') ||
-            err.error.includes('Duplicate endpoint') ||
-            err.error.includes('Duplicate named request') ||
-            err.error.includes('Duplicate sequence'));
-        const otherErrors = importResult.errors.filter(err => !err.error.includes('Duplicate header group') &&
-            !err.error.includes('Duplicate endpoint') &&
-            !err.error.includes('Duplicate named request') &&
-            !err.error.includes('Duplicate sequence'));
-        // Show non-duplicate errors as warnings
-        for (const err of otherErrors) {
-            console.error(colors.warning(`Import warning: ${err.path} - ${err.error}`));
-        }
-        // Duplicate errors block execution
-        if (duplicateErrors.length > 0) {
-            console.error(colors.error('Cannot execute - duplicate definitions found:'));
-            for (const err of duplicateErrors) {
-                console.error(colors.error(`  ${err.path}: ${err.error}`));
-            }
-            process.exit(1);
-        }
-        const fileContentWithImports = importResult.importedContent
-            ? `${importResult.importedContent}\n\n${fileContent}`
-            : fileContent;
-        const apiDefinitions = (importResult.headerGroups?.length || 0) > 0 || (importResult.endpoints?.length || 0) > 0
-            ? { headerGroups: importResult.headerGroups || [], endpoints: importResult.endpoints || [] }
-            : undefined;
-        if (options.request) {
-            const namedRequests = (0, parser_1.extractNamedRequests)(fileContentWithImports);
-            const targetReq = namedRequests.find(r => r.name === options.request);
-            if (!targetReq) {
-                console.error(`Error: Named request '${options.request}' not found`);
-                console.error(`Available requests: ${namedRequests.map(r => r.name).join(', ') || 'none'}`);
-                process.exit(1);
-            }
-            if (options.verbose) {
-                console.log(colors.info(`Running request: ${options.request}`));
-            }
-            const response = await runSingleRequest(targetReq.content, variables, cookieJar, apiDefinitions);
-            // Format and output single request result
-            if (options.output === 'json') {
-                console.log(JSON.stringify({ success: response.status >= 200 && response.status < 400, results: [response] }, null, 2));
-            }
-            else {
-                const isSuccess = response.status >= 200 && response.status < 300;
-                const lines = (0, response_1.formatResponse)(response, { colors, verbose: options.verbose, showDetails: !isSuccess || options.verbose, redaction });
-                for (const line of lines) {
-                    console.log(line);
-                }
-            }
-            process.exit(response.status >= 200 && response.status < 400 ? 0 : 1);
-        }
-        if (options.sequence) {
-            const sequences = (0, sequenceRunner_1.extractSequences)(fileContentWithImports);
-            const targetSeq = sequences.find(s => s.name === options.sequence);
-            if (!targetSeq) {
-                console.error(`Error: Sequence '${options.sequence}' not found`);
-                console.error(`Available sequences: ${sequences.map(s => s.name).join(', ') || 'none'}`);
-                process.exit(1);
-            }
-            if (options.verbose) {
-                console.log(colors.info(`Running sequence: ${options.sequence}`));
-            }
-            const defaultArgs = {};
-            if (targetSeq.parameters) {
-                for (const param of targetSeq.parameters) {
-                    if (param.defaultValue !== undefined) {
-                        defaultArgs[param.name] = param.defaultValue;
-                    }
-                }
-            }
-            const seqResult = await (0, sequenceRunner_1.runSequenceWithJar)(targetSeq.content, variables, cookieJar, workingDir, fileContentWithImports, undefined, undefined, defaultArgs, apiDefinitions, tagFilterOptions, importResult.sequenceSources);
-            seqResult.name = targetSeq.name;
-            // Format and output single sequence result
-            if (options.output === 'json') {
-                console.log(JSON.stringify({ success: seqResult.success, results: [seqResult] }, null, 2));
-            }
-            else {
-                const lines = (0, summary_1.formatSequenceResult)(seqResult, { colors, verbose: options.verbose, redaction });
-                for (const line of lines) {
-                    console.log(line);
-                }
-                const summaryLines = (0, summary_1.formatRunSummary)([seqResult], Date.now() - startTime, colors);
-                for (const line of summaryLines) {
-                    console.log(line);
-                }
-            }
-            process.exit(seqResult.success ? 0 : 1);
-        }
-    }
-    // Count total tests before running
-    let totalTestCount = 0;
-    let filteredTestCount = 0;
-    for (const filePath of filesToRun) {
-        const fileContent = fs.readFileSync(filePath, 'utf-8');
-        const counts = countTestSequences(fileContent, tagFilterOptions);
-        totalTestCount += counts.total;
-        filteredTestCount += counts.filtered;
-    }
-    if (filteredTestCount === 0) {
-        if (totalTestCount > 0 && tagFilterOptions) {
-            console.log(colors.info(`No test sequences match the tag filter (${totalTestCount} total test sequences found)`));
-        }
-        else if (totalTestCount === 0) {
-            console.log(colors.info('No test sequences found. Use "test sequence" to mark sequences for CLI execution.'));
-        }
-        process.exit(0);
-    }
-    if (options.verbose && isDirectory) {
-        const tagInfo = tagFilterOptions ? ` (${filteredTestCount} matching tag filter)` : '';
-        console.log(colors.info(`Running ${filteredTestCount} test sequence(s) from ${filesToRun.length} file(s)${tagInfo}`));
-        console.log('');
-    }
-    // Run tests from each file
-    for (const filePath of filesToRun) {
-        const resolvedEnv = resolveEnvironmentForPath(filePath, options.env);
-        if (resolvedEnv.envNotFound) {
-            console.error(`Error: Environment '${resolvedEnv.envNotFound}' not found in .nornenv`);
-            console.error(`Available environments: ${resolvedEnv.availableEnvironments.join(', ') || 'none'}`);
-            process.exit(1);
-        }
-        if (!resolvedEnv.envFilePath && options.env) {
-            const relPath = isDirectory ? path.relative(inputPath, filePath) : path.basename(filePath);
-            console.error(colors.warning(`Warning: --env specified but no .nornenv file found for ${relPath}`));
-        }
-        mergeSecrets(combinedSecretNames, combinedSecretValues, resolvedEnv.secretNames, resolvedEnv.secretValues);
-        const redaction = (0, redaction_1.createRedactionOptions)(combinedSecretNames, combinedSecretValues, !options.noRedact);
-        const fileContent = fs.readFileSync(filePath, 'utf-8');
-        const fileVariables = (0, parser_1.extractFileLevelVariables)(fileContent);
-        const variables = { ...resolvedEnv.variables, ...fileVariables };
-        const cookieJar = (0, httpClient_1.createCookieJar)();
-        const workingDir = path.dirname(filePath);
-        const importResult = await (0, parser_1.resolveImports)(fileContent, workingDir, async (importPath) => fsPromises.readFile(importPath, 'utf-8'));
-        // Check for duplicate definition errors which should block execution
-        const duplicateErrors2 = importResult.errors.filter(err => err.error.includes('Duplicate header group') ||
-            err.error.includes('Duplicate endpoint') ||
-            err.error.includes('Duplicate named request') ||
-            err.error.includes('Duplicate sequence'));
-        const otherErrors2 = importResult.errors.filter(err => !err.error.includes('Duplicate header group') &&
-            !err.error.includes('Duplicate endpoint') &&
-            !err.error.includes('Duplicate named request') &&
-            !err.error.includes('Duplicate sequence'));
-        // Show non-duplicate errors as warnings
-        for (const err of otherErrors2) {
-            console.error(colors.warning(`Import warning: ${err.path} - ${err.error}`));
-        }
-        // Duplicate errors block execution
-        if (duplicateErrors2.length > 0) {
-            console.error(colors.error('Cannot execute - duplicate definitions found:'));
-            for (const err of duplicateErrors2) {
-                console.error(colors.error(`  ${err.path}: ${err.error}`));
-            }
-            process.exit(1);
-        }
-        const fileContentWithImports = importResult.importedContent
-            ? `${importResult.importedContent}\n\n${fileContent}`
-            : fileContent;
-        // Check if file has test sequences
-        const allSequences = (0, sequenceRunner_1.extractSequences)(fileContent);
-        const testSequences = allSequences.filter(seq => seq.isTest);
-        const sequences = tagFilterOptions && tagFilterOptions.filters.length > 0
-            ? testSequences.filter(seq => (0, sequenceRunner_1.sequenceMatchesTags)(seq, tagFilterOptions))
-            : testSequences;
-        if (sequences.length === 0) {
-            // No test sequences in this file, skip
-            continue;
-        }
-        // Show file header in directory mode
-        if (isDirectory && options.output !== 'json') {
-            const relPath = path.relative(inputPath, filePath);
-            console.log(colors.info(`\n━━━ ${relPath} ━━━`));
-        }
-        const apiDefinitions = (importResult.headerGroups?.length || 0) > 0 || (importResult.endpoints?.length || 0) > 0
-            ? { headerGroups: importResult.headerGroups || [], endpoints: importResult.endpoints || [] }
-            : undefined;
-        const seqResults = await runAllSequences(fileContentWithImports, variables, cookieJar, workingDir, apiDefinitions, tagFilterOptions, importResult.sequenceSources);
-        // Tag results with source file for reporting
-        for (const result of seqResults) {
-            result.sourceFile = filePath;
-            allResults.push(result);
-            if (!result.success) {
-                overallSuccess = false;
-            }
-            allErrors.push(...result.errors);
-        }
-        // Output per-file results in pretty mode
-        if (options.output !== 'json') {
-            for (const seqResult of seqResults) {
-                const lines = (0, summary_1.formatSequenceResult)(seqResult, { colors, verbose: options.verbose, redaction });
-                for (const line of lines) {
-                    console.log(line);
-                }
-            }
-        }
-    }
-    const totalDuration = Date.now() - startTime;
-    const redaction = (0, redaction_1.createRedactionOptions)(combinedSecretNames, combinedSecretValues, !options.noRedact);
-    // Build result object for reporting
-    const result = {
-        success: overallSuccess,
-        type: 'all-sequences',
-        results: allResults,
-        errors: allErrors,
-    };
-    // Determine report paths
-    let junitOutputPath = options.junitOutput;
-    let htmlOutputPath = options.htmlOutput;
-    // If --output-dir is specified, auto-generate timestamped filenames
-    if (options.outputDir) {
-        const timestamp = generateTimestamp();
-        // Use input path name for report naming
-        const baseName = isDirectory ? path.basename(inputPath) : path.basename(inputPath, path.extname(inputPath));
-        const generatedPaths = generateReportPaths(options.outputDir, baseName + '.norn', timestamp);
-        // Only use generated paths if explicit paths weren't provided
-        if (!junitOutputPath) {
-            junitOutputPath = generatedPaths.junitPath;
-        }
-        if (!htmlOutputPath) {
-            htmlOutputPath = generatedPaths.htmlPath;
-        }
-        // Ensure output directory exists
-        if (!fs.existsSync(options.outputDir)) {
-            fs.mkdirSync(options.outputDir, { recursive: true });
-        }
-    }
-    // Generate reports if requested
-    if (junitOutputPath) {
-        const suiteName = isDirectory ? path.basename(inputPath) : path.basename(inputPath, path.extname(inputPath));
-        if (result.type === 'request') {
-            (0, junit_1.generateJUnitReportFromResponse)(result.results[0], options.request || suiteName, { outputPath: junitOutputPath, redaction, suiteName });
-        }
-        else {
-            (0, junit_1.generateJUnitReport)(result.results, { outputPath: junitOutputPath, redaction, suiteName });
-        }
-        console.log(colors.info(`JUnit report written to: ${junitOutputPath}`));
-    }
-    if (htmlOutputPath) {
-        const title = `Norn Test Report - ${path.basename(inputPath)}`;
-        if (result.type === 'request') {
-            (0, html_1.generateHtmlReportFromResponse)(result.results[0], options.request || path.basename(inputPath), { outputPath: htmlOutputPath, redaction, title });
-        }
-        else {
-            (0, html_1.generateHtmlReport)(result.results, { outputPath: htmlOutputPath, redaction, title });
-        }
-        console.log(colors.info(`HTML report written to: ${htmlOutputPath}`));
-    }
-    // Output results
-    if (options.output === 'json') {
-        // Redact JSON output
-        const redactedResult = {
-            ...result,
-            results: result.results.map(r => {
-                if ('responses' in r) {
-                    // SequenceResult
-                    return {
-                        ...r,
-                        responses: r.responses.map(resp => ({
-                            ...resp,
-                            body: (0, redaction_1.redactBody)(resp.body, redaction)
-                        })),
-                        steps: r.steps.map(step => ({
-                            ...step,
-                            response: step.response ? {
-                                ...step.response,
-                                body: (0, redaction_1.redactBody)(step.response.body, redaction)
-                            } : undefined
-                        }))
-                    };
-                }
-                else {
-                    // HttpResponse
-                    return {
-                        ...r,
-                        body: (0, redaction_1.redactBody)(r.body, redaction)
-                    };
-                }
-            })
-        };
-        console.log(JSON.stringify(redactedResult, null, 2));
-    }
-    else {
-        // Pretty output - summary only (individual results already printed per-file)
-        if (result.type !== 'request' && allResults.length > 0) {
-            // Show summary
-            const summaryLines = (0, summary_1.formatRunSummary)(allResults, totalDuration, colors);
-            for (const line of summaryLines) {
-                console.log(line);
-            }
-        }
-        if (result.errors.length > 0 && result.type === 'request') {
-            console.error(`\n${colors.error('Errors:')}`);
-            result.errors.forEach(err => console.error(`  ${colors.bullet} ${err}`));
-        }
-    }
-    // Exit with appropriate code
-    if (options.failOnError && !overallSuccess) {
-        process.exit(1);
-    }
-}
-main().catch((error) => {
-    console.error('Fatal error:', error.message);
-    process.exit(1);
-});
-//# sourceMappingURL=cli.js.map