norn-cli 1.3.17 → 1.3.19

package/out/cli.js

@@ -0,0 +1,926 @@
+"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';
+/**
+ * Finds .nornenv file relative to a specific file path (for CLI usage)
+ */
+function findEnvFileFromPath(filePath) {
+    let dir = path.dirname(filePath);
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const envPath = path.join(dir, ENV_FILENAME);
+        if (fs.existsSync(envPath)) {
+            return envPath;
+        }
+        dir = path.dirname(dir);
+    }
+    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;
+}
+/**
+ * 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();
+    // Find env file from the input path (directory or file)
+    const envFilePath = findEnvFileFromPath(inputPath);
+    let envVariables = {};
+    let redaction = (0, redaction_1.createRedactionOptions)(new Set(), new Map(), !options.noRedact);
+    if (envFilePath) {
+        const envContent = fs.readFileSync(envFilePath, 'utf-8');
+        const envConfig = parseEnvFile(envContent);
+        envVariables = { ...envConfig.common };
+        redaction = (0, redaction_1.createRedactionOptions)(envConfig.secretNames, envConfig.secretValues, !options.noRedact);
+        if (options.env) {
+            const targetEnv = envConfig.environments.find(e => e.name === options.env);
+            if (!targetEnv) {
+                console.error(`Error: Environment '${options.env}' not found in .nornenv`);
+                console.error(`Available environments: ${envConfig.environments.map(e => e.name).join(', ') || 'none'}`);
+                process.exit(1);
+            }
+            Object.assign(envVariables, targetEnv.variables);
+            for (const [name, value] of Object.entries(targetEnv.variables)) {
+                if (envConfig.secretNames.has(name)) {
+                    redaction.secretValues.set(name, value);
+                }
+            }
+            if (options.verbose) {
+                console.log(colors.info(`Using environment: ${options.env}`));
+            }
+        }
+    }
+    else if (options.env) {
+        console.error(colors.warning(`Warning: --env specified but no .nornenv file found`));
+    }
+    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 fileContent = fs.readFileSync(filePath, 'utf-8');
+        const fileVariables = (0, parser_1.extractFileLevelVariables)(fileContent);
+        const variables = { ...envVariables, ...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 fileContent = fs.readFileSync(filePath, 'utf-8');
+        const fileVariables = (0, parser_1.extractFileLevelVariables)(fileContent);
+        const variables = { ...envVariables, ...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;
+    // 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