norn-cli 1.4.3 → 1.4.5

package/.norn-cache/swagger-body-intellisense.json

@@ -3,7 +3,7 @@
   "urls": {
     "https://petstore.swagger.io/v2/swagger.json": {
       "baseUrl": "https://petstore.swagger.io/v2",
-      "fetchedAt": "2026-02-22T11:34:46.683Z",
+      "fetchedAt": "2026-02-24T16:44:27.288Z",
       "schemas": [
         {
           "operationId": "AddPet",

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 All notable changes to the "Norn" extension will be documented in this file.
 
+## [1.4.5] - 2026-02-24
+
+### Fixed
+- **Diagnostics False Positive (JSON Property Assignment)**:
+  - Fixed editor squiggles on valid JSON property assignments with array indexing, for example `config.users[0].name = "Updated Alice"`.
+
+## [1.4.4] - 2026-02-24
+
+### Improved
+- **Error UX (Extension + CLI)**:
+  - Added structured, more actionable request/sequence error messages with environment-aware hints.
+  - Improved preflight validation so unresolved variables and invalid URLs are caught before request execution.
+  - Standardized error formatting across extension response panel and CLI output.
+
+- **Response Panel Error Readability**:
+  - Sequence errors/warnings now render as timeline entries (same visual style as execution steps) and appear at the end of the run.
+  - Error details are grouped into clearer sections with primary fields surfaced first.
+
+- **Diagnostics Coverage and Persistence**:
+  - Expanded `.norn` editor diagnostics for malformed statements and invalid command combinations.
+  - Added workspace-wide diagnostic refresh so Explorer error badges persist after files are closed.
+
+### Fixed
+- **Diagnostics False Positives**:
+  - Fixed false squiggles for valid request body variable lines (for example `payload` used as a request body).
+  - Fixed false squiggles for endpoint calls with parameters (for example `GET MultiParam(hello, world)` and named args).
+  - Fixed false squiggles for commented-out empty variable references (`{{}}`) in comment lines.
+
+- **Preflight Validation Regression**:
+  - Fixed request preflight validation incorrectly blocking some `GET`/`HEAD` requests due to unresolved placeholders detected in parsed body content.
+
 ## [1.4.3] - 2026-02-22
 
 ### Improved

package/dist/cli.js

@@ -26208,6 +26208,29 @@ var CookieJar = class _CookieJar {
   }
 };
 
+// src/errors/nornError.ts
+var NornError = class 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] : void 0;
+    this.context = options.context;
+    this.cause = options.cause;
+  }
+};
+function isNornError(error) {
+  return error instanceof NornError;
+}
+
 // src/httpClient.ts
 var sharedCookieJar = new CookieJar();
 function createCookieJar() {
@@ -26368,8 +26391,41 @@ async function sendRequestWithJar(request, jar, retryOptions) {
       return result;
     } catch (error) {
       const errorMessage = error.message || String(error);
-      lastError = new Error(`${errorMessage}
-URL used: ${currentUrl || request.url}`);
+      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({
+          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({
+          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}
+URL used: ${effectiveUrl}`);
+      }
       if (attempt < totalAttempts) {
         const waitMs = backoffMs * attempt;
         retriedErrors.push(`Attempt ${attempt}: ${errorMessage}`);
@@ -26758,6 +26814,202 @@ function parsePropertyAssignment(line2) {
   };
 }
 
+// src/errors/formatError.ts
+function mergeContext(base, overrides) {
+  if (!base && !overrides) {
+    return void 0;
+  }
+  return {
+    ...base || {},
+    ...overrides || {},
+    environment: {
+      ...base?.environment || {},
+      ...overrides?.environment || {}
+    }
+  };
+}
+function normalizeKnownError(error, context) {
+  if (isNornError(error)) {
+    if (!context) {
+      return error;
+    }
+    return new 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({
+        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(void 0, context)
+      });
+    }
+    if (msg.startsWith("Unknown endpoint: ")) {
+      const endpointName = msg.slice("Unknown endpoint: ".length).trim();
+      return new 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(void 0, context)
+      });
+    }
+    if (/invalid url/i.test(msg) || /unsupported protocol/i.test(msg)) {
+      return new 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(void 0, context)
+      });
+    }
+    return error;
+  }
+  return new Error(String(error));
+}
+function formatUserFacingError(error, context) {
+  const normalized = normalizeKnownError(error, context);
+  if (!isNornError(normalized)) {
+    if (normalized instanceof Error) {
+      return normalized.message;
+    }
+    return String(normalized);
+  }
+  const lines = [normalized.message];
+  const ctx = normalized.context;
+  if (ctx?.stepIndex !== void 0) {
+    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 env3 = ctx.environment;
+    if (env3.hasEnvFile) {
+      const active = env3.activeEnvironment ?? "none";
+      const available = env3.availableEnvironments?.length ? env3.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");
+}
+
+// src/requestValidation.ts
+var PLACEHOLDER_REGEX = /\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g;
+function collectUnresolvedPlaceholders(text) {
+  if (!text) {
+    return [];
+  }
+  const names = /* @__PURE__ */ new Set();
+  let match;
+  PLACEHOLDER_REGEX.lastIndex = 0;
+  while ((match = PLACEHOLDER_REGEX.exec(text)) !== null) {
+    names.add(match[1]);
+  }
+  return [...names];
+}
+function buildMissingVariableHint(missingVars, context) {
+  const env3 = context?.environment;
+  if (env3?.hasEnvFile && env3.availableEnvironments && env3.availableEnvironments.length > 0 && !env3.activeEnvironment) {
+    return `A .nornenv file was found but no environment is selected. Select one of: ${env3.availableEnvironments.join(", ")}.`;
+  }
+  if (env3?.hasEnvFile && env3.activeEnvironment) {
+    return `Check that ${missingVars.map((v) => `'${v}'`).join(", ")} exist in the active environment '${env3.activeEnvironment}' or as file-level variables.`;
+  }
+  return `Define ${missingVars.length === 1 ? "the variable" : "the variables"} ${missingVars.map((v) => `'${v}'`).join(", ")} before sending the request.`;
+}
+function buildRequestContext(parsed, context) {
+  return {
+    ...context,
+    method: context?.method || parsed.method,
+    url: context?.url || parsed.url,
+    environment: context?.environment
+  };
+}
+function describeUnresolvedLocation(label, vars) {
+  if (vars.length === 0) {
+    return void 0;
+  }
+  return `${label}: unresolved ${vars.length === 1 ? "variable" : "variables"} ${vars.map((v) => `{{${v}}}`).join(", ")}`;
+}
+function shouldValidateBodyPlaceholders(parsed) {
+  const method = String(parsed.method || "").toUpperCase();
+  return method !== "GET" && method !== "HEAD";
+}
+function validatePreparedRequest(parsed, context) {
+  const urlVars = collectUnresolvedPlaceholders(parsed.url);
+  const headerVars = [...new Set(Object.values(parsed.headers).flatMap((value) => collectUnresolvedPlaceholders(value)))];
+  const bodyVars = shouldValidateBodyPlaceholders(parsed) ? collectUnresolvedPlaceholders(parsed.body) : [];
+  const missingVars = [.../* @__PURE__ */ new Set([...urlVars, ...headerVars, ...bodyVars])];
+  if (missingVars.length > 0) {
+    const details = [
+      describeUnresolvedLocation("URL", urlVars),
+      describeUnresolvedLocation("Headers", headerVars),
+      describeUnresolvedLocation("Body", bodyVars)
+    ].filter((d) => Boolean(d));
+    throw new NornError({
+      category: "variable-resolution",
+      code: "unresolved-request-variables",
+      message: `Request could not be prepared: unresolved ${missingVars.length === 1 ? "variable" : "variables"} ${missingVars.map((v) => `{{${v}}}`).join(", ")}.`,
+      details,
+      hint: buildMissingVariableHint(missingVars, context),
+      context: {
+        ...buildRequestContext(parsed, context),
+        unresolvedVariables: missingVars
+      }
+    });
+  }
+  if (!parsed.url || !parsed.url.trim()) {
+    throw new NornError({
+      category: "url",
+      code: "missing-request-url",
+      message: "Request URL is missing.",
+      hint: "Add a URL after the HTTP method (for example: GET https://api.example.com/path).",
+      context: buildRequestContext(parsed, context)
+    });
+  }
+  try {
+    new URL(parsed.url);
+  } catch (error) {
+    throw new NornError({
+      category: "url",
+      code: "invalid-request-url",
+      message: `Invalid request URL: ${parsed.url}`,
+      details: error instanceof Error ? error.message : String(error),
+      hint: "Check the URL format and any variables used to build it.",
+      context: buildRequestContext(parsed, context),
+      cause: error
+    });
+  }
+}
+
 // src/sequenceRunner.ts
 init_assertionRunner();
 function applyHeaderGroupsToRequest(parsed, requestText, headerGroups, variables) {
@@ -26818,6 +27070,9 @@ function applyHeaderGroupsToRequest(parsed, requestText, headerGroups, variables
   }
   return result;
 }
+function indentMultiline(value, prefix = "  ") {
+  return value.split("\n").map((line2) => `${prefix}${line2}`).join("\n");
+}
 function isRunNamedRequestCommand(line2) {
   const trimmed = line2.trim();
   if (!trimmed.toLowerCase().startsWith("run ")) {
@@ -27930,7 +28185,7 @@ function getValueByPath(response, path5) {
       return void 0;
   }
 }
-async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, workingDir, fullDocumentText, onProgress, callStack, sequenceArgs, apiDefinitions, tagFilterOptions, sequenceSources) {
+async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, workingDir, fullDocumentText, onProgress, callStack, sequenceArgs, apiDefinitions, tagFilterOptions, sequenceSources, executionContext) {
   const startTime = Date.now();
   const responses = [];
   const scriptResults = [];
@@ -27960,6 +28215,16 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
     }
   };
   const runtimeVariables = { ...fileVariables, ...sequenceArgs };
+  const buildRequestValidationContext = (stepNumber, method, url2, requestName) => ({
+    source: "sequence",
+    filePath: executionContext?.filePath,
+    sequenceName: executionContext?.sequenceName,
+    stepIndex: stepNumber,
+    method,
+    url: url2,
+    requestName,
+    environment: executionContext?.environment
+  });
   let requestIndex = 0;
   const ifStack = [];
   const shouldSkip = () => ifStack.length > 0 && ifStack.some((v) => !v);
@@ -28341,6 +28606,10 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           }
         }
         const requestParsed = parserHttpRequest(requestText, runtimeVariables);
+        validatePreparedRequest(
+          requestParsed,
+          buildRequestValidationContext(stepIdx + 1, requestParsed.method, requestParsed.url, `var ${parsed.varName}`)
+        );
         const retryOpts = parsed.retryCount ? {
           retryCount: parsed.retryCount,
           backoffMs: parsed.backoffMs || 1e3,
@@ -28372,8 +28641,13 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           }
         }
       } catch (error) {
-        let errorDetails = `Request failed for var ${parsed.varName}: ${error.message}`;
-        if (requestDescription) {
+        const userMessage = formatUserFacingError(
+          error,
+          buildRequestValidationContext(stepIdx + 1, void 0, void 0, `var ${parsed.varName}`)
+        );
+        let errorDetails = `Request failed for var ${parsed.varName}:
+${indentMultiline(userMessage)}`;
+        if (requestDescription && !/\nRequest:\s/.test(userMessage)) {
           errorDetails += `
   Request: ${requestDescription}`;
         }
@@ -28558,8 +28832,9 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           // Pass API definitions for endpoint resolution
           tagFilterOptions,
           // Pass tag filter options for nested sequence filtering
-          sequenceSources
+          sequenceSources,
           // Pass sequence sources for nested sequences
+          executionContext
         );
         reportProgress(stepIdx, "sequenceEnd", `Finished sequence ${targetName}`, void 0, targetName);
         for (const subResponse of subResult.responses) {
@@ -28674,6 +28949,10 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
         }
         requestUrl = requestParsed.url;
         requestMethod = requestParsed.method;
+        validatePreparedRequest(
+          requestParsed,
+          buildRequestValidationContext(stepIdx + 1, requestMethod, requestUrl, targetName)
+        );
         const effectiveRetryCount = parsed.retryCount ?? requestParsed.retryCount;
         const effectiveBackoffMs = parsed.backoffMs ?? requestParsed.backoffMs ?? 1e3;
         const retryOpts = effectiveRetryCount ? {
@@ -28704,8 +28983,13 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           }
         }
       } catch (error) {
-        let errorDetails = `Named request "${targetName}" failed: ${error.message}`;
-        if (requestUrl) {
+        const userMessage = formatUserFacingError(
+          error,
+          buildRequestValidationContext(stepIdx + 1, requestMethod || void 0, requestUrl || void 0, targetName)
+        );
+        let errorDetails = `Named request "${targetName}" failed:
+${indentMultiline(userMessage)}`;
+        if (requestUrl && !/\nRequest:\s/.test(userMessage)) {
           errorDetails += `
   Request: ${requestMethod} ${requestUrl}`;
         }
@@ -28774,6 +29058,10 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           const requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
           requestUrl = requestParsed.url;
           requestMethod = requestParsed.method;
+          validatePreparedRequest(
+            requestParsed,
+            buildRequestValidationContext(stepIdx + 1, requestMethod, requestUrl, `${varName} = run ${sequenceName}`)
+          );
           const effectiveRetryCount = parsed.retryCount ?? requestParsed.retryCount;
           const effectiveBackoffMs = parsed.backoffMs ?? requestParsed.backoffMs ?? 1e3;
           const retryOpts = effectiveRetryCount ? {
@@ -28811,8 +29099,13 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
             }
           }
         } catch (error) {
-          let errorDetails = `Named request "${sequenceName}" failed: ${error.message}`;
-          if (requestUrl) {
+          const userMessage = formatUserFacingError(
+            error,
+            buildRequestValidationContext(stepIdx + 1, requestMethod || void 0, requestUrl || void 0, `${varName} = run ${sequenceName}`)
+          );
+          let errorDetails = `Named request "${sequenceName}" failed:
+${indentMultiline(userMessage)}`;
+          if (requestUrl && !/\nRequest:\s/.test(userMessage)) {
             errorDetails += `
   Request: ${requestMethod} ${requestUrl}`;
           }
@@ -28890,8 +29183,9 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
         // Pass API definitions for endpoint resolution
         tagFilterOptions,
         // Pass tag filter options for nested sequence filtering
-        sequenceSources
+        sequenceSources,
         // Pass sequence sources for nested sequences
+        executionContext
       );
       reportProgress(stepIdx, "sequenceEnd", `Finished sequence ${sequenceName}`, void 0, sequenceName);
       for (const subResponse of subResult.responses) {
@@ -29030,6 +29324,10 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           }
         }
         const { retryCount, backoffMs } = extractRetryOptions(step.content);
+        validatePreparedRequest(
+          parsed,
+          buildRequestValidationContext(stepIdx + 1, parsed.method, parsed.url)
+        );
         const retryOpts = retryCount ?? parsed.retryCount ? {
           retryCount: retryCount ?? parsed.retryCount ?? 0,
           backoffMs: backoffMs ?? parsed.backoffMs ?? 1e3,
@@ -29058,8 +29356,13 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           }
         }
       } catch (error) {
-        let errorDetails = `Request ${requestIndex} failed: ${error.message}`;
-        if (requestDescription) {
+        const userMessage = formatUserFacingError(
+          error,
+          buildRequestValidationContext(stepIdx + 1)
+        );
+        let errorDetails = `Request ${requestIndex} failed:
+${indentMultiline(userMessage)}`;
+        if (requestDescription && !/\nRequest:\s/.test(userMessage)) {
           errorDetails += `
   Request: ${requestDescription}`;
         }
@@ -30396,6 +30699,13 @@ function mergeSecrets(targetNames, targetValues, sourceNames, sourceValues) {
     targetValues.set(name, value);
   }
 }
+function buildCliEnvironmentValidationContext(resolvedEnv, selectedEnv) {
+  return {
+    hasEnvFile: Boolean(resolvedEnv.envFilePath),
+    activeEnvironment: selectedEnv,
+    availableEnvironments: resolvedEnv.availableEnvironments
+  };
+}
 function generateTimestamp() {
   const now = /* @__PURE__ */ new Date();
   const year = now.getFullYear();
@@ -30534,7 +30844,7 @@ Examples:
   norn api-tests.norn --no-redact           # Show all data (no redaction)
 `);
 }
-async function runSingleRequest(fileContent, variables, cookieJar, apiDefinitions) {
+async function runSingleRequest(fileContent, variables, cookieJar, apiDefinitions, filePath, envContext) {
   const lines = fileContent.split("\n");
   const requestLines = [];
   let foundRequestLine = false;
@@ -30602,8 +30912,16 @@ async function runSingleRequest(fileContent, variables, cookieJar, apiDefinition
           headers: combinedHeaders,
           body: apiRequest.body
         };
+        validatePreparedRequest(parsed2, {
+          source: "cli",
+          filePath,
+          method: parsed2.method,
+          url: parsed2.url,
+          environment: envContext
+        });
         return await sendRequestWithJar(parsed2, cookieJar);
       }
+      throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
     }
   }
   let parsed = parserHttpRequest(requestContent, variables);
@@ -30649,6 +30967,13 @@ async function runSingleRequest(fileContent, variables, cookieJar, apiDefinition
     }
     parsed.url = parsed.url.trim();
   }
+  validatePreparedRequest(parsed, {
+    source: "cli",
+    filePath,
+    method: parsed.method,
+    url: parsed.url,
+    environment: envContext
+  });
   return await sendRequestWithJar(parsed, cookieJar);
 }
 function discoverNornFiles(dirPath) {
@@ -30689,7 +31014,7 @@ function formatCaseLabel(params) {
   });
   return `[${parts.join(", ")}]`;
 }
-async function runAllSequences(fileContent, variables, cookieJar, workingDir, apiDefinitions, tagFilterOptions, sequenceSources) {
+async function runAllSequences(fileContent, variables, cookieJar, workingDir, apiDefinitions, tagFilterOptions, sequenceSources, executionContext) {
   const allSequences = extractSequences(fileContent);
   const results = [];
   const testSequences = allSequences.filter((seq) => seq.isTest);
@@ -30734,7 +31059,8 @@ async function runAllSequences(fileContent, variables, cookieJar, workingDir, ap
           caseArgs,
           apiDefinitions,
           tagFilterOptions,
-          sequenceSources
+          sequenceSources,
+          { ...executionContext, sequenceName: seq.name }
         );
         result.name = `${seq.name}${caseLabel}`;
         results.push(result);
@@ -30759,7 +31085,8 @@ async function runAllSequences(fileContent, variables, cookieJar, workingDir, ap
         defaultArgs,
         apiDefinitions,
         tagFilterOptions,
-        sequenceSources
+        sequenceSources,
+        { ...executionContext, sequenceName: seq.name }
       );
       result.name = seq.name;
       results.push(result);
@@ -30823,6 +31150,7 @@ async function main() {
   if (options.sequence || options.request) {
     const filePath = filesToRun[0];
     const resolvedEnv = resolveEnvironmentForPath(filePath, options.env);
+    const envValidationContext = buildCliEnvironmentValidationContext(resolvedEnv, options.env);
     if (resolvedEnv.envNotFound) {
       console.error(`Error: Environment '${resolvedEnv.envNotFound}' not found in .nornenv`);
       console.error(`Available environments: ${resolvedEnv.availableEnvironments.join(", ") || "none"}`);
@@ -30876,7 +31204,7 @@ ${fileContent}` : fileContent;
       if (options.verbose) {
         console.log(colors.info(`Running request: ${options.request}`));
       }
-      const response = await runSingleRequest(targetReq.content, variables, cookieJar, apiDefinitions);
+      const response = await runSingleRequest(targetReq.content, variables, cookieJar, apiDefinitions, filePath, envValidationContext);
       if (options.output === "json") {
         console.log(JSON.stringify({ success: response.status >= 200 && response.status < 400, results: [response] }, null, 2));
       } else {
@@ -30918,7 +31246,8 @@ ${fileContent}` : fileContent;
         defaultArgs,
         apiDefinitions,
         tagFilterOptions,
-        importResult.sequenceSources
+        importResult.sequenceSources,
+        { filePath, sequenceName: targetSeq.name, environment: envValidationContext }
       );
       seqResult.name = targetSeq.name;
       if (options.output === "json") {
@@ -30959,6 +31288,7 @@ ${fileContent}` : fileContent;
   }
   for (const filePath of filesToRun) {
     const resolvedEnv = resolveEnvironmentForPath(filePath, options.env);
+    const envValidationContext = buildCliEnvironmentValidationContext(resolvedEnv, options.env);
     if (resolvedEnv.envNotFound) {
       console.error(`Error: Environment '${resolvedEnv.envNotFound}' not found in .nornenv`);
       console.error(`Available environments: ${resolvedEnv.availableEnvironments.join(", ") || "none"}`);
@@ -31011,7 +31341,16 @@ ${fileContent}` : fileContent;
 \u2501\u2501\u2501 ${relPath} \u2501\u2501\u2501`));
     }
     const apiDefinitions = (importResult.headerGroups?.length || 0) > 0 || (importResult.endpoints?.length || 0) > 0 ? { headerGroups: importResult.headerGroups || [], endpoints: importResult.endpoints || [] } : void 0;
-    const seqResults = await runAllSequences(fileContentWithImports, variables, cookieJar, workingDir, apiDefinitions, tagFilterOptions, importResult.sequenceSources);
+    const seqResults = await runAllSequences(
+      fileContentWithImports,
+      variables,
+      cookieJar,
+      workingDir,
+      apiDefinitions,
+      tagFilterOptions,
+      importResult.sequenceSources,
+      { filePath, environment: envValidationContext }
+    );
     for (const result2 of seqResults) {
       result2.sourceFile = filePath;
       allResults.push(result2);
@@ -31131,7 +31470,8 @@ ${colors.error("Errors:")}`);
   }
 }
 main().catch((error) => {
-  console.error("Fatal error:", error.message);
+  const message = formatUserFacingError(error, { source: "cli" });
+  console.error("Fatal error:", message);
   process.exit(1);
 });
 /*! Bundled license information:

package/package.json

@@ -2,7 +2,7 @@
   "name": "norn-cli",
   "displayName": "Norn - REST Client",
   "description": "A powerful REST client for making HTTP requests with sequences, variables, scripts, and cookie support",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "publisher": "Norn-PeterKrustanov",
   "author": {
     "name": "Peter Krastanov"