norn-cli 1.3.16 → 1.3.18

package/out/cli/formatters/assertion.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Assertion formatter for CLI output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAssertion = formatAssertion;
+exports.formatAssertionSummary = formatAssertionSummary;
+/**
+ * Format a single assertion result
+ */
+function formatAssertion(assertion, options) {
+    const { colors, verbose } = options;
+    const lines = [];
+    const icon = assertion.passed ? colors.checkmark : colors.cross;
+    // Build display expression with friendly name when available
+    let displayExpr = assertion.expression;
+    if (assertion.friendlyName && assertion.responseIndex) {
+        // Replace $N with the friendly variable name
+        displayExpr = displayExpr.replace('$' + assertion.responseIndex, assertion.friendlyName);
+    }
+    const displayMessage = assertion.message || displayExpr;
+    lines.push(`${icon} assert ${displayMessage}`);
+    // Show details for failures, or for all assertions in verbose mode
+    if (!assertion.passed || verbose) {
+        if (assertion.error) {
+            lines.push(`    ${colors.error(`Error: ${assertion.error}`)}`);
+        }
+        else if (!assertion.passed) {
+            // Show expected vs actual for failures
+            lines.push(`    ${colors.dim('Expected:')} ${formatValue(assertion.rightExpression ?? assertion.operator)}`);
+            lines.push(`    ${colors.dim('Actual:')} ${formatValue(assertion.leftValue)}`);
+            // If expressions differ from values, show original expressions
+            if (verbose && assertion.leftExpression !== String(assertion.leftValue)) {
+                lines.push(`    ${colors.dim('Expression:')} ${assertion.leftExpression}`);
+            }
+        }
+        else if (verbose) {
+            // In verbose mode, show values for passing assertions too
+            lines.push(`    ${colors.dim('Value:')} ${formatValue(assertion.leftValue)}`);
+        }
+    }
+    return lines;
+}
+/**
+ * Format a value for display (handles objects, arrays, primitives)
+ */
+function formatValue(value) {
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+/**
+ * Format assertion summary (passed/failed counts)
+ */
+function formatAssertionSummary(results, colors) {
+    const passed = results.filter(a => a.passed).length;
+    const failed = results.length - passed;
+    if (failed > 0) {
+        return `${colors.error(`${passed}/${results.length} assertions passed`)} (${failed} failed)`;
+    }
+    return `${colors.success(`${passed}/${results.length} assertions passed`)}`;
+}
+//# sourceMappingURL=assertion.js.map

package/out/cli/formatters/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * CLI formatters index - re-exports all formatter functions
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./response"), exports);
+__exportStar(require("./assertion"), exports);
+__exportStar(require("./summary"), exports);
+//# sourceMappingURL=index.js.map

package/out/cli/formatters/response.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * HTTP Response formatter for CLI output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatResponse = formatResponse;
+exports.formatResponseCompact = formatResponseCompact;
+const colors_1 = require("../colors");
+const redaction_1 = require("../redaction");
+/**
+ * Format a single HTTP response for CLI output
+ */
+function formatResponse(response, options) {
+    const { colors, redaction, verbose, showDetails, index, method, url } = options;
+    const lines = [];
+    const prefix = index !== undefined ? `[${index}] ` : '';
+    const statusColor = (0, colors_1.getStatusColor)(colors, response.status);
+    const isSuccess = response.status >= 200 && response.status < 300;
+    const icon = isSuccess ? colors.checkmark : colors.cross;
+    // Status line with optional method/url
+    if (method && url) {
+        const displayUrl = (0, redaction_1.redactUrl)(url, redaction);
+        const retryInfo = response.retryInfo && response.retryInfo.attemptsMade > 1
+            ? ` ${colors.warning(`[retried ${response.retryInfo.attemptsMade - 1}x]`)}`
+            : '';
+        lines.push(`${prefix}${icon} ${colors.method(method)} ${displayUrl} ` +
+            `${statusColor(`(${response.status} ${response.statusText})`)} ` +
+            `${colors.duration((0, colors_1.formatDuration)(response.duration))}${retryInfo}`);
+    }
+    else {
+        const retryInfo = response.retryInfo && response.retryInfo.attemptsMade > 1
+            ? ` ${colors.warning(`[retried ${response.retryInfo.attemptsMade - 1}x]`)}`
+            : '';
+        lines.push(`${prefix}${statusColor(`${response.status} ${response.statusText}`)} ` +
+            `${colors.duration(`(${(0, colors_1.formatDuration)(response.duration)})`)}${retryInfo}`);
+    }
+    // Only show details in verbose mode OR when there's an error/showDetails is true
+    if (verbose || showDetails) {
+        lines.push((0, colors_1.line)());
+        // Request details (if available and showing details)
+        if (showDetails && (options.requestHeaders || options.requestBody)) {
+            lines.push(colors.bold('Request:'));
+            if (options.requestHeaders) {
+                const redactedHeaders = (0, redaction_1.redactHeaders)(options.requestHeaders, redaction);
+                for (const [key, value] of Object.entries(redactedHeaders)) {
+                    lines.push(`  ${colors.header(key)}: ${colors.headerValue(value)}`);
+                }
+            }
+            if (options.requestBody) {
+                lines.push('');
+                lines.push(colors.dim('  Body:'));
+                const redactedBody = (0, redaction_1.redactBody)(options.requestBody, redaction);
+                const bodyStr = typeof redactedBody === 'object'
+                    ? JSON.stringify(redactedBody, null, 2)
+                    : String(redactedBody);
+                for (const bodyLine of bodyStr.split('\n')) {
+                    lines.push(`  ${colors.dim(bodyLine)}`);
+                }
+            }
+            lines.push('');
+            lines.push(colors.bold('Response:'));
+        }
+        // Response headers (verbose or on error)
+        if (verbose && response.headers) {
+            lines.push(colors.dim('Headers:'));
+            const redactedHeaders = (0, redaction_1.redactHeaders)(response.headers, redaction);
+            for (const [key, value] of Object.entries(redactedHeaders)) {
+                lines.push(`  ${colors.header(key)}: ${colors.headerValue(value)}`);
+            }
+            lines.push((0, colors_1.line)());
+        }
+        // Response body
+        if (response.body !== undefined && response.body !== null) {
+            const redactedBody = (0, redaction_1.redactBody)(response.body, redaction);
+            if (typeof redactedBody === 'object') {
+                lines.push(JSON.stringify(redactedBody, null, 2));
+            }
+            else {
+                lines.push(String(redactedBody));
+            }
+        }
+    }
+    return lines;
+}
+/**
+ * Format a compact one-line response (for quiet mode on success)
+ */
+function formatResponseCompact(response, options) {
+    const { colors, redaction, method, url, index } = options;
+    const prefix = index !== undefined ? `[${index}] ` : '';
+    const statusColor = (0, colors_1.getStatusColor)(colors, response.status);
+    const isSuccess = response.status >= 200 && response.status < 300;
+    const icon = isSuccess ? colors.checkmark : colors.cross;
+    const retryInfo = response.retryInfo && response.retryInfo.attemptsMade > 1
+        ? ` ${colors.warning(`[retried ${response.retryInfo.attemptsMade - 1}x]`)}`
+        : '';
+    if (method && url) {
+        const displayUrl = (0, redaction_1.redactUrl)(url, redaction);
+        return (`${prefix}${icon} ${colors.method(method)} ${displayUrl} ` +
+            `${statusColor(`${response.status}`)} ` +
+            `${colors.duration((0, colors_1.formatDuration)(response.duration))}${retryInfo}`);
+    }
+    return (`${prefix}${icon} ${statusColor(`${response.status} ${response.statusText}`)} ` +
+        `${colors.duration((0, colors_1.formatDuration)(response.duration))}${retryInfo}`);
+}
+//# sourceMappingURL=response.js.map

package/out/cli/formatters/summary.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Summary formatter for CLI output - formats sequence results and overall run summaries
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSequenceResult = formatSequenceResult;
+exports.formatRunSummary = formatRunSummary;
+exports.formatProgressLine = formatProgressLine;
+const colors_1 = require("../colors");
+const response_1 = require("./response");
+const assertion_1 = require("./assertion");
+/**
+ * Format a single sequence result
+ */
+function formatSequenceResult(result, options) {
+    const { colors, redaction, verbose } = options;
+    const lines = [];
+    // Sequence header
+    const statusIcon = result.success ? colors.checkmark : colors.cross;
+    const statusColor = result.success ? colors.success : colors.error;
+    lines.push('');
+    lines.push(`${statusIcon} ${statusColor(`Sequence: ${result.name}`)}`);
+    lines.push(`${colors.dim('Duration:')} ${(0, colors_1.formatDuration)(result.duration)}`);
+    // Assertion summary if any
+    if (result.assertionResults && result.assertionResults.length > 0) {
+        lines.push(`${colors.dim('Assertions:')} ${(0, assertion_1.formatAssertionSummary)(result.assertionResults, colors)}`);
+    }
+    // Request count
+    const requestCount = result.steps.filter(s => s.type === 'request').length;
+    lines.push(`${colors.dim('Requests:')} ${requestCount}`);
+    lines.push((0, colors_1.doubleLine)());
+    // Track if we've shown any expanded details
+    let requestIdx = 0;
+    // Print steps in order
+    for (const step of result.steps) {
+        const stepLines = formatStep(step, {
+            colors,
+            redaction,
+            verbose,
+            requestIndex: step.type === 'request' ? ++requestIdx : undefined,
+        });
+        lines.push(...stepLines);
+    }
+    // Show accumulated errors/warnings at the end
+    if (result.errors.length > 0) {
+        lines.push('');
+        lines.push(colors.warning('Warnings/Errors:'));
+        for (const err of result.errors) {
+            lines.push(`  ${colors.bullet} ${err}`);
+        }
+    }
+    return lines;
+}
+/**
+ * Format a single step result
+ */
+function formatStep(step, options) {
+    const { colors, redaction, verbose, requestIndex } = options;
+    switch (step.type) {
+        case 'print':
+            return formatPrintStep(step, colors);
+        case 'request':
+            return formatRequestStep(step, { colors, redaction, verbose, requestIndex });
+        case 'assertion':
+            return formatAssertionStep(step, { colors, verbose });
+        case 'script':
+            return formatScriptStep(step, colors, verbose);
+        case 'json':
+            return formatJsonStep(step, colors, verbose);
+        default:
+            return [];
+    }
+}
+function formatPrintStep(step, colors) {
+    const lines = [];
+    if (step.print) {
+        lines.push(`${colors.warning('[print]')} ${step.print.title}`);
+        if (step.print.body) {
+            lines.push(`        ${step.print.body}`);
+        }
+    }
+    return lines;
+}
+function formatRequestStep(step, options) {
+    const { colors, redaction, verbose, requestIndex } = options;
+    if (!step.response) {
+        return [];
+    }
+    const isSuccess = step.response.status >= 200 && step.response.status < 300;
+    // In quiet mode (not verbose), only show compact line for successful requests
+    // Show full details for failures
+    if (!verbose && isSuccess) {
+        return [(0, response_1.formatResponseCompact)(step.response, {
+                colors,
+                redaction,
+                method: step.requestMethod,
+                url: step.requestUrl,
+                index: requestIndex,
+            })];
+    }
+    // Show full details for failures or in verbose mode
+    return (0, response_1.formatResponse)(step.response, {
+        colors,
+        redaction,
+        verbose,
+        showDetails: !isSuccess || verbose, // Show request details on failure or verbose
+        index: requestIndex,
+        method: step.requestMethod,
+        url: step.requestUrl,
+        requestBody: step.response.requestBody,
+        requestHeaders: step.response.requestHeaders,
+    });
+}
+function formatAssertionStep(step, options) {
+    if (!step.assertion) {
+        return [];
+    }
+    return (0, assertion_1.formatAssertion)(step.assertion, {
+        colors: options.colors,
+        verbose: options.verbose,
+    });
+}
+function formatScriptStep(step, colors, verbose) {
+    const lines = [];
+    if (step.script) {
+        const icon = step.script.success ? colors.checkmark : colors.cross;
+        lines.push(`${icon} ${colors.dim('[script]')} ${step.script.type}`);
+        if (!step.script.success || verbose) {
+            if (step.script.error) {
+                lines.push(`    ${colors.error(`Error: ${step.script.error}`)}`);
+            }
+            if (verbose && step.script.output) {
+                lines.push(`    ${colors.dim('output:')} ${step.script.output}`);
+            }
+        }
+    }
+    return lines;
+}
+function formatJsonStep(step, colors, verbose) {
+    const lines = [];
+    if (step.json) {
+        const icon = step.json.success ? colors.checkmark : colors.cross;
+        lines.push(`${icon} ${colors.dim('[json]')} Loaded: ${step.json.varName}`);
+        if (!step.json.success) {
+            lines.push(`    ${colors.error(`Error: ${step.json.error}`)}`);
+        }
+        else if (verbose) {
+            lines.push(`    ${colors.dim('File:')} ${step.json.filePath}`);
+        }
+    }
+    return lines;
+}
+/**
+ * Format the overall run summary (for multiple sequences)
+ */
+function formatRunSummary(results, totalDuration, colors) {
+    const lines = [];
+    const passed = results.filter(r => r.success).length;
+    const failed = results.length - passed;
+    lines.push('');
+    lines.push((0, colors_1.doubleLine)());
+    lines.push(colors.bold('Summary'));
+    lines.push((0, colors_1.line)());
+    lines.push(`${colors.dim('Total sequences:')} ${results.length}`);
+    lines.push(`${colors.success(`Passed: ${passed}`)}`);
+    if (failed > 0) {
+        lines.push(`${colors.error(`Failed: ${failed}`)}`);
+        // List failed sequences
+        lines.push('');
+        lines.push(colors.error('Failed sequences:'));
+        for (const result of results.filter(r => !r.success)) {
+            lines.push(`  ${colors.cross} ${result.name}`);
+        }
+    }
+    lines.push('');
+    lines.push(`${colors.dim('Total duration:')} ${(0, colors_1.formatDuration)(totalDuration)}`);
+    return lines;
+}
+/**
+ * Format a single-line progress indicator (for streaming output)
+ */
+function formatProgressLine(sequenceName, currentStep, totalSteps, stepDescription, colors) {
+    return (`${colors.info(`[${sequenceName}]`)} ` +
+        `${colors.dim(`Step ${currentStep}/${totalSteps}:`)} ` +
+        `${stepDescription}`);
+}
+//# sourceMappingURL=summary.js.map

package/out/cli/redaction.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * Redaction module for sensitive data in CLI output
+ *
+ * Automatically redacts:
+ * - Authorization headers (Bearer tokens, Basic auth, API keys)
+ * - Common sensitive field names (password, secret, token, api_key, etc.)
+ * - User-defined secrets from .nornenv `secret` declarations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRedactionOptions = createRedactionOptions;
+exports.redactHeaders = redactHeaders;
+exports.redactString = redactString;
+exports.redactBody = redactBody;
+exports.redactUrl = redactUrl;
+exports.getRedactedMarker = getRedactedMarker;
+const REDACTED = '***REDACTED***';
+/**
+ * Common header names that should always be redacted
+ */
+const SENSITIVE_HEADERS = new Set([
+    'authorization',
+    'x-api-key',
+    'x-auth-token',
+    'x-access-token',
+    'api-key',
+    'apikey',
+    'cookie',
+    'set-cookie',
+    'x-csrf-token',
+    'x-xsrf-token',
+]);
+/**
+ * Patterns for sensitive values in headers/bodies
+ * These patterns match common token/key formats
+ */
+const SENSITIVE_PATTERNS = [
+    // Bearer tokens
+    /Bearer\s+[A-Za-z0-9\-_=]+\.?[A-Za-z0-9\-_=]*\.?[A-Za-z0-9\-_=]*/gi,
+    // Basic auth
+    /Basic\s+[A-Za-z0-9+/=]+/gi,
+    // API keys (common formats)
+    /api[_-]?key[=:]\s*["']?[A-Za-z0-9\-_]+["']?/gi,
+];
+/**
+ * Field names in JSON that should have their values redacted
+ */
+const SENSITIVE_FIELD_NAMES = new Set([
+    'password',
+    'passwd',
+    'secret',
+    'token',
+    'access_token',
+    'accesstoken',
+    'refresh_token',
+    'refreshtoken',
+    'api_key',
+    'apikey',
+    'api-key',
+    'private_key',
+    'privatekey',
+    'client_secret',
+    'clientsecret',
+    'auth',
+    'authorization',
+    'credential',
+    'credentials',
+]);
+/**
+ * Create default redaction options
+ */
+function createRedactionOptions(secretNames = new Set(), secretValues = new Map(), enabled = true) {
+    return { secretNames, secretValues, enabled };
+}
+/**
+ * Redact sensitive headers
+ */
+function redactHeaders(headers, options) {
+    if (!options.enabled) {
+        return headers;
+    }
+    const redacted = {};
+    for (const [key, value] of Object.entries(headers)) {
+        const lowerKey = key.toLowerCase();
+        // Check if header name is sensitive
+        if (SENSITIVE_HEADERS.has(lowerKey)) {
+            redacted[key] = REDACTED;
+            continue;
+        }
+        // Check for Bearer/Basic patterns in value
+        let redactedValue = value;
+        for (const pattern of SENSITIVE_PATTERNS) {
+            redactedValue = redactedValue.replace(pattern, REDACTED);
+        }
+        // Check if value matches any secret values
+        redactedValue = redactSecretValues(redactedValue, options);
+        redacted[key] = redactedValue;
+    }
+    return redacted;
+}
+/**
+ * Redact sensitive values in a string
+ */
+function redactString(text, options) {
+    if (!options.enabled || !text) {
+        return text;
+    }
+    let result = text;
+    // Apply pattern-based redaction
+    for (const pattern of SENSITIVE_PATTERNS) {
+        result = result.replace(pattern, REDACTED);
+    }
+    // Redact user-defined secret values
+    result = redactSecretValues(result, options);
+    return result;
+}
+/**
+ * Redact secret values from .nornenv
+ */
+function redactSecretValues(text, options) {
+    if (!text || options.secretValues.size === 0) {
+        return text;
+    }
+    let result = text;
+    // Replace each secret value with redacted marker
+    for (const [, value] of options.secretValues) {
+        if (value && value.length > 0) {
+            // Escape special regex characters in the value
+            const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            result = result.replace(new RegExp(escaped, 'g'), REDACTED);
+        }
+    }
+    return result;
+}
+/**
+ * Redact sensitive fields in JSON body
+ */
+function redactBody(body, options) {
+    if (!options.enabled) {
+        return body;
+    }
+    if (typeof body === 'string') {
+        // Try to parse as JSON first
+        try {
+            const parsed = JSON.parse(body);
+            return JSON.stringify(redactObject(parsed, options), null, 2);
+        }
+        catch {
+            // Not JSON, apply string redaction
+            return redactString(body, options);
+        }
+    }
+    if (typeof body === 'object' && body !== null) {
+        return redactObject(body, options);
+    }
+    return body;
+}
+/**
+ * Recursively redact sensitive fields in an object
+ */
+function redactObject(obj, options) {
+    if (Array.isArray(obj)) {
+        return obj.map(item => redactObject(item, options));
+    }
+    if (typeof obj !== 'object' || obj === null) {
+        if (typeof obj === 'string') {
+            return redactSecretValues(obj, options);
+        }
+        return obj;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const lowerKey = key.toLowerCase();
+        // Check if field name indicates sensitive data
+        if (SENSITIVE_FIELD_NAMES.has(lowerKey)) {
+            result[key] = REDACTED;
+            continue;
+        }
+        // Check if this is a user-defined secret variable name
+        if (options.secretNames.has(key)) {
+            result[key] = REDACTED;
+            continue;
+        }
+        // Recursively process nested objects
+        if (typeof value === 'object' && value !== null) {
+            result[key] = redactObject(value, options);
+        }
+        else if (typeof value === 'string') {
+            result[key] = redactSecretValues(value, options);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Redact a URL (query parameters with sensitive names)
+ */
+function redactUrl(url, options) {
+    if (!options.enabled) {
+        return url;
+    }
+    try {
+        const urlObj = new URL(url);
+        const params = new URLSearchParams(urlObj.search);
+        let modified = false;
+        for (const [key] of params.entries()) {
+            const lowerKey = key.toLowerCase();
+            if (SENSITIVE_FIELD_NAMES.has(lowerKey) ||
+                lowerKey.includes('token') ||
+                lowerKey.includes('key') ||
+                lowerKey.includes('secret') ||
+                lowerKey.includes('password')) {
+                params.set(key, REDACTED);
+                modified = true;
+            }
+        }
+        if (modified) {
+            urlObj.search = params.toString();
+            return urlObj.toString();
+        }
+        // Also redact secret values that appear in the URL
+        return redactSecretValues(url, options);
+    }
+    catch {
+        // If URL parsing fails, just do string-based redaction
+        return redactSecretValues(url, options);
+    }
+}
+/**
+ * Get the redaction marker (for display purposes)
+ */
+function getRedactedMarker() {
+    return REDACTED;
+}
+//# sourceMappingURL=redaction.js.map