norn-cli 2.4.0 → 2.6.0

package/out/errors/formatError.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatUserFacingError = formatUserFacingError;
-const nornError_1 = require("./nornError");
-function mergeContext(base, overrides) {
-    if (!base && !overrides) {
-        return undefined;
-    }
-    return {
-        ...(base || {}),
-        ...(overrides || {}),
-        environment: {
-            ...(base?.environment || {}),
-            ...(overrides?.environment || {})
-        }
-    };
-}
-function normalizeKnownError(error, context) {
-    if ((0, nornError_1.isNornError)(error)) {
-        if (!context) {
-            return error;
-        }
-        return new nornError_1.NornError({
-            category: error.category,
-            code: error.code,
-            message: error.message,
-            hint: error.hint,
-            details: error.details,
-            context: mergeContext(error.context, context),
-            cause: error.cause
-        });
-    }
-    if (error instanceof Error) {
-        const msg = error.message || String(error);
-        if (msg === 'No valid HTTP method found') {
-            return new nornError_1.NornError({
-                category: 'syntax',
-                code: 'request-missing-method',
-                message: 'Could not parse request: no valid HTTP method found.',
-                hint: 'Start the request with a valid HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS).',
-                context: mergeContext(undefined, context)
-            });
-        }
-        if (msg.startsWith('Unknown endpoint: ')) {
-            const endpointName = msg.slice('Unknown endpoint: '.length).trim();
-            return new nornError_1.NornError({
-                category: 'validation',
-                code: 'unknown-endpoint',
-                message: `Unknown endpoint '${endpointName}'.`,
-                hint: 'Import a .nornapi file that defines this endpoint, or fix the endpoint name.',
-                context: mergeContext(undefined, context)
-            });
-        }
-        if (/invalid url/i.test(msg) || /unsupported protocol/i.test(msg)) {
-            return new nornError_1.NornError({
-                category: 'url',
-                code: 'invalid-url',
-                message: `Invalid request URL.`,
-                details: msg,
-                hint: 'Check the request URL and any substituted variables (for example {{baseUrl}}).',
-                context: mergeContext(undefined, context)
-            });
-        }
-        return error;
-    }
-    return new Error(String(error));
-}
-function formatUserFacingError(error, context) {
-    const normalized = normalizeKnownError(error, context);
-    if (!(0, nornError_1.isNornError)(normalized)) {
-        if (normalized instanceof Error) {
-            return normalized.message;
-        }
-        return String(normalized);
-    }
-    const lines = [normalized.message];
-    const ctx = normalized.context;
-    if (ctx?.stepIndex !== undefined) {
-        lines.push(`Step: ${ctx.stepIndex}`);
-    }
-    if (ctx?.requestName) {
-        lines.push(`Request: ${ctx.requestName}`);
-    }
-    else if (ctx?.method || ctx?.url) {
-        const requestLine = [ctx.method, ctx.url].filter(Boolean).join(' ');
-        if (requestLine) {
-            lines.push(`Request: ${requestLine}`);
-        }
-    }
-    if (ctx?.filePath) {
-        lines.push(`File: ${ctx.filePath}`);
-    }
-    if (ctx?.environment) {
-        const env = ctx.environment;
-        if (env.hasEnvFile) {
-            const active = env.activeEnvironment ?? 'none';
-            const available = env.availableEnvironments?.length
-                ? env.availableEnvironments.join(', ')
-                : 'none';
-            lines.push(`Environment: ${active} (available: ${available})`);
-        }
-    }
-    if (normalized.details) {
-        for (const detail of normalized.details) {
-            lines.push(detail);
-        }
-    }
-    if (normalized.hint) {
-        lines.push(`Hint: ${normalized.hint}`);
-    }
-    return lines.join('\n');
-}
-//# sourceMappingURL=formatError.js.map

package/out/errors/nornError.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NornError = void 0;
-exports.isNornError = isNornError;
-class NornError extends Error {
-    category;
-    code;
-    hint;
-    details;
-    context;
-    cause;
-    constructor(options) {
-        super(options.message);
-        this.name = 'NornError';
-        this.category = options.category;
-        this.code = options.code;
-        this.hint = options.hint;
-        this.details = Array.isArray(options.details)
-            ? options.details
-            : options.details ? [options.details] : undefined;
-        this.context = options.context;
-        this.cause = options.cause;
-    }
-}
-exports.NornError = NornError;
-function isNornError(error) {
-    return error instanceof NornError;
-}
-//# sourceMappingURL=nornError.js.map

package/out/formUrlEncoded.js

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFormUrlEncodedContentType = isFormUrlEncodedContentType;
-exports.parseFormUrlEncodedLines = parseFormUrlEncodedLines;
-exports.parseFormUrlEncodedBody = parseFormUrlEncodedBody;
-exports.encodeFormUrlEncodedBody = encodeFormUrlEncodedBody;
-function parseEqualsField(segment) {
-    const eqIndex = segment.indexOf('=');
-    if (eqIndex <= 0) {
-        return null;
-    }
-    return {
-        key: segment.substring(0, eqIndex).trim(),
-        value: segment.substring(eqIndex + 1).trim()
-    };
-}
-function isFormUrlEncodedContentType(contentType) {
-    return Boolean(contentType && contentType.toLowerCase().includes('application/x-www-form-urlencoded'));
-}
-function parseFormUrlEncodedLines(lines) {
-    const fields = [];
-    const errors = [];
-    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
-        const line = lines[lineIndex].trim();
-        if (!line) {
-            continue;
-        }
-        const firstEqIndex = line.indexOf('=');
-        const firstColonIndex = line.indexOf(':');
-        if (firstEqIndex > 0 && (firstColonIndex === -1 || firstEqIndex < firstColonIndex)) {
-            if (line.includes('&')) {
-                const segments = line.split('&').map(segment => segment.trim());
-                const hasInvalidSegment = segments.some(segment => !parseEqualsField(segment));
-                if (hasInvalidSegment) {
-                    errors.push({
-                        lineIndex,
-                        line,
-                        message: 'Ampersand-delimited form body lines must use key=value for every segment.'
-                    });
-                    continue;
-                }
-                for (const segment of segments) {
-                    const field = parseEqualsField(segment);
-                    if (field) {
-                        fields.push(field);
-                    }
-                }
-                continue;
-            }
-            const field = parseEqualsField(line);
-            if (field) {
-                fields.push(field);
-                continue;
-            }
-        }
-        if (firstColonIndex > 0) {
-            fields.push({
-                key: line.substring(0, firstColonIndex).trim(),
-                value: line.substring(firstColonIndex + 1).trim()
-            });
-            continue;
-        }
-        errors.push({
-            lineIndex,
-            line,
-            message: 'Expected key=value, key: value, or ampersand-delimited key=value pairs.'
-        });
-    }
-    return { fields, errors };
-}
-function parseFormUrlEncodedBody(body) {
-    if (!body) {
-        return { fields: [], errors: [] };
-    }
-    return parseFormUrlEncodedLines(body.split('\n'));
-}
-function encodeFormUrlEncodedBody(body) {
-    const { fields, errors } = parseFormUrlEncodedBody(body);
-    if (errors.length > 0) {
-        return { encodedBody: '', errors };
-    }
-    return {
-        encodedBody: fields
-            .map(field => `${encodeURIComponent(field.key)}=${encodeURIComponent(field.value)}`)
-            .join('&'),
-        errors: []
-    };
-}
-//# sourceMappingURL=formUrlEncoded.js.map

package/out/httpClient.js

@@ -1,348 +0,0 @@
-"use strict";
-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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCookieJar = createCookieJar;
-exports.getSharedCookieJar = getSharedCookieJar;
-exports.clearCookies = clearCookies;
-exports.getCookiesForUrl = getCookiesForUrl;
-exports.getAllCookies = getAllCookies;
-exports.sendRequest = sendRequest;
-exports.sendRequestWithJar = sendRequestWithJar;
-const axios_1 = __importDefault(require("axios"));
-const https = __importStar(require("https"));
-const tough_cookie_1 = require("tough-cookie");
-const nornError_1 = require("./errors/nornError");
-const httpRuntimeOptions_1 = require("./httpRuntimeOptions");
-const formUrlEncoded_1 = require("./formUrlEncoded");
-// Shared cookie jar for VS Code extension (persists across requests)
-let sharedCookieJar = new tough_cookie_1.CookieJar();
-const insecureHttpsAgent = new https.Agent({ rejectUnauthorized: false });
-function getHttpsAgent() {
-    return (0, httpRuntimeOptions_1.getVerifyTlsCertificates)() ? undefined : insecureHttpsAgent;
-}
-/**
- * Creates a fresh cookie jar for isolated execution (CLI, sequences)
- */
-function createCookieJar() {
-    return new tough_cookie_1.CookieJar();
-}
-/**
- * Gets the shared cookie jar
- */
-function getSharedCookieJar() {
-    return sharedCookieJar;
-}
-/**
- * Clears all cookies from the shared jar
- */
-function clearCookies() {
-    sharedCookieJar = new tough_cookie_1.CookieJar();
-}
-/**
- * Gets all cookies from a jar for a specific URL
- */
-async function getCookiesForUrl(url, jar) {
-    const targetJar = jar || sharedCookieJar;
-    try {
-        const cookies = await targetJar.getCookies(url);
-        return cookies.map(cookieToInfo);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Gets all cookies from a jar
- */
-async function getAllCookies(jar) {
-    const targetJar = jar || sharedCookieJar;
-    const serialized = await targetJar.serialize();
-    return (serialized.cookies || []).map((c) => ({
-        name: String(c.key || ''),
-        value: String(c.value || ''),
-        domain: String(c.domain || ''),
-        path: String(c.path || '/'),
-        expires: c.expires ? String(c.expires) : undefined,
-        httpOnly: Boolean(c.httpOnly),
-        secure: Boolean(c.secure),
-    }));
-}
-function cookieToInfo(cookie) {
-    return {
-        name: cookie.key,
-        value: cookie.value,
-        domain: cookie.domain || '',
-        path: cookie.path || '/',
-        expires: cookie.expires instanceof Date ? cookie.expires.toISOString() : undefined,
-        httpOnly: cookie.httpOnly || false,
-        secure: cookie.secure || false,
-    };
-}
-/**
- * Sends a request using the shared cookie jar (for VS Code extension)
- */
-async function sendRequest(request, retryOptions) {
-    return sendRequestWithJar(request, sharedCookieJar, retryOptions);
-}
-/**
- * Helper function to wait
- */
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-/**
- * Check if a response indicates failure (should retry)
- * Retries on: network errors, 5xx server errors, 429 rate limit
- */
-function shouldRetry(response, error) {
-    // Always retry on network errors
-    if (error) {
-        return true;
-    }
-    // Retry on server errors (5xx) or rate limiting (429)
-    if (response && (response.status >= 500 || response.status === 429)) {
-        return true;
-    }
-    return false;
-}
-/**
- * Sends a request using a specific cookie jar
- * Manually follows redirects to properly capture Set-Cookie headers at each step
- * Supports automatic retry with linear backoff
- */
-async function sendRequestWithJar(request, jar, retryOptions) {
-    const totalAttempts = (retryOptions?.retryCount ?? 0) + 1; // +1 for initial attempt
-    const backoffMs = retryOptions?.backoffMs ?? 1000;
-    const retriedErrors = [];
-    let lastError = null;
-    let attemptsMade = 0;
-    for (let attempt = 1; attempt <= totalAttempts; attempt++) {
-        attemptsMade = attempt;
-        const startTime = Date.now();
-        const maxRedirects = 10;
-        let redirectCount = 0;
-        let currentUrl = request.url;
-        let currentMethod = request.method;
-        let currentBody = request.body;
-        let finalResponse = null;
-        let sentRequestBody = undefined;
-        let sentRequestHeaders = {};
-        try {
-            while (redirectCount <= maxRedirects) {
-                // Get cookies for current URL
-                const existingCookies = await jar.getCookies(currentUrl);
-                const cookieHeader = existingCookies.map(c => `${c.key}=${c.value}`).join('; ');
-                const headers = { ...request.headers };
-                if (cookieHeader) {
-                    headers['Cookie'] = cookieHeader;
-                }
-                // Determine how to send the body based on Content-Type
-                let data = undefined;
-                if (currentBody) {
-                    const contentType = Object.keys(headers).find((key) => key.toLowerCase() === 'content-type');
-                    const contentTypeValue = contentType ? headers[contentType] : '';
-                    if ((0, formUrlEncoded_1.isFormUrlEncodedContentType)(contentTypeValue)) {
-                        const encoded = (0, formUrlEncoded_1.encodeFormUrlEncodedBody)(currentBody);
-                        if (encoded.errors.length > 0) {
-                            throw new nornError_1.NornError({
-                                category: 'syntax',
-                                code: 'invalid-form-urlencoded-body',
-                                message: 'Request body is not valid application/x-www-form-urlencoded syntax.',
-                                details: encoded.errors.map(error => `Body line ${error.lineIndex + 1}: ${error.message} (${error.line})`),
-                                hint: 'Use key=value, key: value, or a single line like key1=value1&key2=value2.',
-                                context: {
-                                    source: 'httpClient',
-                                    method: currentMethod,
-                                    url: currentUrl
-                                }
-                            });
-                        }
-                        data = encoded.encodedBody;
-                    }
-                    else if (contentTypeValue.includes('application/json')) {
-                        try {
-                            data = JSON.parse(currentBody);
-                        }
-                        catch {
-                            data = currentBody;
-                        }
-                    }
-                    else {
-                        try {
-                            data = JSON.parse(currentBody);
-                        }
-                        catch {
-                            data = currentBody;
-                        }
-                    }
-                }
-                // Capture what we're actually sending (for debugging)
-                sentRequestBody = data;
-                sentRequestHeaders = { ...headers };
-                const response = await (0, axios_1.default)({
-                    method: currentMethod,
-                    url: currentUrl,
-                    adapter: 'http',
-                    headers,
-                    data,
-                    timeout: 30000,
-                    maxRedirects: 0,
-                    validateStatus: () => true,
-                    httpsAgent: getHttpsAgent(),
-                });
-                // Store any Set-Cookie headers in the jar
-                const setCookieHeader = response.headers['set-cookie'];
-                if (setCookieHeader) {
-                    const cookies = Array.isArray(setCookieHeader) ? setCookieHeader : [setCookieHeader];
-                    for (const cookieStr of cookies) {
-                        try {
-                            await jar.setCookie(cookieStr, currentUrl);
-                        }
-                        catch {
-                            // Ignore invalid cookies
-                        }
-                    }
-                }
-                // Check if this is a redirect
-                if (response.status >= 300 && response.status < 400 && response.headers['location']) {
-                    redirectCount++;
-                    const location = response.headers['location'];
-                    currentUrl = new URL(location, currentUrl).toString();
-                    if (currentMethod !== 'GET' && currentMethod !== 'HEAD') {
-                        currentMethod = 'GET';
-                        currentBody = undefined;
-                    }
-                    continue;
-                }
-                finalResponse = response;
-                break;
-            }
-            if (!finalResponse) {
-                throw new Error('Too many redirects');
-            }
-            // Check if we should retry on this response status
-            if (shouldRetry(finalResponse, null) && attempt < totalAttempts) {
-                const waitMs = backoffMs * attempt; // Linear backoff
-                const errorMessage = `HTTP ${finalResponse.status} ${finalResponse.statusText}`;
-                retriedErrors.push(`Attempt ${attempt}: ${errorMessage}`);
-                // Call retry callback if provided
-                if (retryOptions?.onRetry) {
-                    retryOptions.onRetry(attempt, totalAttempts, errorMessage, waitMs);
-                }
-                await sleep(waitMs);
-                continue;
-            }
-            // Get ALL cookies in the jar
-            const cookies = await getAllCookies(jar);
-            const result = {
-                status: finalResponse.status,
-                statusText: finalResponse.statusText,
-                headers: finalResponse.headers,
-                body: finalResponse.data,
-                duration: Date.now() - startTime,
-                cookies,
-                requestBody: sentRequestBody,
-                requestHeaders: sentRequestHeaders,
-            };
-            // Add retry info if we made retries
-            if (attemptsMade > 1 || totalAttempts > 1) {
-                result.retryInfo = {
-                    attemptsMade,
-                    totalAttempts,
-                    retriedErrors,
-                };
-            }
-            return result;
-        }
-        catch (error) {
-            const errorMessage = error.message || String(error);
-            const effectiveUrl = currentUrl || request.url;
-            const isUrlError = /invalid url/i.test(errorMessage) || /unsupported protocol/i.test(errorMessage);
-            const isAxiosNetworkError = Boolean(error?.isAxiosError) && !error?.response;
-            if (isUrlError) {
-                lastError = new nornError_1.NornError({
-                    category: 'url',
-                    code: 'http-invalid-url',
-                    message: `Invalid request URL: ${effectiveUrl}`,
-                    details: errorMessage,
-                    hint: 'Check the URL and any variables used to build it before sending the request.',
-                    context: {
-                        source: 'httpClient',
-                        method: currentMethod,
-                        url: effectiveUrl,
-                    },
-                    cause: error,
-                });
-            }
-            else if (isAxiosNetworkError) {
-                lastError = new nornError_1.NornError({
-                    category: 'network',
-                    code: 'http-network-error',
-                    message: `Network request failed.`,
-                    details: [`${errorMessage}`, `URL used: ${effectiveUrl}`],
-                    hint: 'Check connectivity, DNS/host availability, TLS settings, and the request URL.',
-                    context: {
-                        source: 'httpClient',
-                        method: currentMethod,
-                        url: effectiveUrl,
-                    },
-                    cause: error,
-                });
-            }
-            else {
-                lastError = new Error(`${errorMessage}\nURL used: ${effectiveUrl}`);
-            }
-            // If we have more attempts, wait and retry
-            if (attempt < totalAttempts) {
-                const waitMs = backoffMs * attempt; // Linear backoff
-                retriedErrors.push(`Attempt ${attempt}: ${errorMessage}`);
-                // Call retry callback if provided
-                if (retryOptions?.onRetry) {
-                    retryOptions.onRetry(attempt, totalAttempts, errorMessage, waitMs);
-                }
-                await sleep(waitMs);
-                continue;
-            }
-            // No more retries, throw the error
-            throw lastError;
-        }
-    }
-    // Should never reach here, but TypeScript needs this
-    throw lastError || new Error('Request failed');
-}
-//# sourceMappingURL=httpClient.js.map

package/out/httpRuntimeOptions.js

@@ -1,16 +0,0 @@
-"use strict";
-/**
- * Shared runtime HTTP options for extension + CLI execution paths.
- * Keep this module Node-only (no VS Code imports).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setVerifyTlsCertificates = setVerifyTlsCertificates;
-exports.getVerifyTlsCertificates = getVerifyTlsCertificates;
-let verifyTlsCertificates = true;
-function setVerifyTlsCertificates(enabled) {
-    verifyTlsCertificates = enabled;
-}
-function getVerifyTlsCertificates() {
-    return verifyTlsCertificates;
-}
-//# sourceMappingURL=httpRuntimeOptions.js.map

package/out/importErrors.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBlockingImportError = isBlockingImportError;
-exports.getBlockingImportErrors = getBlockingImportErrors;
-exports.splitImportResolutionErrors = splitImportResolutionErrors;
-const BLOCKING_IMPORT_ERROR_MARKERS = [
-    'Duplicate header group',
-    'Duplicate endpoint',
-    'Duplicate named request',
-    'Duplicate sequence',
-];
-function isBlockingImportError(error) {
-    return Boolean(error.blocking) || BLOCKING_IMPORT_ERROR_MARKERS.some(marker => error.error.includes(marker));
-}
-function getBlockingImportErrors(errors) {
-    return errors.filter(isBlockingImportError);
-}
-function splitImportResolutionErrors(errors) {
-    const blockingErrors = [];
-    const warningErrors = [];
-    for (const error of errors) {
-        if (isBlockingImportError(error)) {
-            blockingErrors.push(error);
-        }
-        else {
-            warningErrors.push(error);
-        }
-    }
-    return { blockingErrors, warningErrors };
-}
-//# sourceMappingURL=importErrors.js.map