norn-cli 2.3.0 → 2.4.0

package/out/errors/formatError.js

@@ -0,0 +1,113 @@
+"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

@@ -0,0 +1,29 @@
+"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

@@ -0,0 +1,89 @@
+"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

@@ -0,0 +1,348 @@
+"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

@@ -0,0 +1,16 @@
+"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

@@ -0,0 +1,31 @@
+"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