norn-cli 1.2.2 → 1.2.4

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to the "Norn" extension will be documented in this file.
 
+## [1.2.4] - 2026-02-07
+
+### Improved
+- **Enhanced failure experience**: Failed assertions now display much richer context
+  - **Friendly variable names**: Shows `user.body.status` instead of `$1.body.status` when response was assigned to a variable
+  - **Auto-expand failures**: Failed assertions automatically expand to show details
+  - **Inline response preview**: Failed assertions include a collapsible preview of the related response body
+  - **JSON path highlighting**: The failing field is highlighted in the response preview
+  - **Request labels**: Request steps in sequences show variable names (e.g., `user`) instead of `$1`
+- Same improvements apply to CLI output and Test Explorer
+
+## [1.2.3] - 2026-02-07
+
+### Added
+- **Duplicate import detection**: Errors shown when importing files with duplicate definitions
+  - Header groups and endpoints from `.nornapi` files
+  - Named requests and sequences from `.norn` files
+  - Blocks execution in CLI, VS Code, and Test Explorer
+  - Red squiggly on import line with descriptive error message
+
+### Fixed
+- **.nornenv validation**: `secret var = value` now shows error (use `secret name = value` instead)
+  - Syntax highlighting marks invalid pattern in red
+  - Diagnostic message explains correct usage
+- **IntelliSense context**: Script types (`bash`, `powershell`, `js`, `readJson`) only appear after `run` keyword
+- **var keyword highlighting**: `var` keyword stays colored while typing variable name
+
 ## [1.2.2] - 2026-02-05
 
 ### Added

package/README.md

@@ -79,7 +79,7 @@ sequence Example
     GET https://api.example.com/users/{{userId}}
     var userName = $1.body.name
     
-    print Result | {{message}}, Name: {{userName}}
+    print "Result" | "{{message}}, Name: {{userName}}"
 end sequence
 ```
 
@@ -133,14 +133,14 @@ sequence Login
     Content-Type: application/json
     {"username": "admin", "password": "secret"}
     var token = $1.body.accessToken
-    print Logged in | Token: {{token}}
+    print "Logged in" | "Token: {{token}}"
 end sequence
 
 # Define reusable teardown sequence
 sequence Logout
     POST {{baseUrl}}/auth/logout
     Authorization: Bearer {{token}}
-    print Logged out
+    print "Logged out"
 end sequence
 
 # Main test sequence uses setup/teardown
@@ -171,7 +171,7 @@ Sequences can accept parameters with optional default values:
 ```bash
 # Required parameter
 sequence Greet(name)
-    print Hello, {{name}}!
+    print "Hello, {{name}}!"
 end sequence
 
 # Optional parameter with default
@@ -218,8 +218,8 @@ sequence MyTests
     var user = run FetchUser("123")
     
     # Access individual fields
-    print User name: {{user.name}}
-    print User email: {{user.email}}
+    print "User name" | "{{user.name}}"
+    print "User email" | "{{user.email}}"
     
     # Use in requests
     POST {{baseUrl}}/messages
@@ -434,7 +434,7 @@ sequence UserTests
     
     # Capture response to variable
     var user = GET GetUser(1) Json
-    print User | {{user.body.name}}
+    print "User" | "{{user.body.name}}"
     
     # Use variables in endpoint parameters
     var userId = 5
@@ -551,7 +551,7 @@ sequence AuthFlow
     
     # Run another named request
     run GetProfile
-    print Profile | Welcome, {{$2.body.name}}!
+    print "Profile" | "Welcome, {{$2.body.name}}!"
 end sequence
 ```
 
@@ -565,7 +565,7 @@ sequence ConditionalFlow
     
     # Execute block only if condition is true
     if $1.status == 200
-        print Success | User found!
+        print "Success" | "User found!"
         
         GET https://api.example.com/users/1/orders
         assert $2.status == 200
@@ -573,12 +573,12 @@ sequence ConditionalFlow
     
     # Check for errors
     if $1.status == 404
-        print Error | User not found
+        print "Error" | "User not found"
     end if
     
     # Conditions support all assertion operators
     if $1.body.role == "admin"
-        print Admin | User has admin privileges
+        print "Admin" | "User has admin privileges"
     end if
 end sequence
 ```
@@ -592,7 +592,7 @@ sequence RateLimitedFlow
     POST https://api.example.com/jobs
     var jobId = $1.body.id
     
-    print Waiting | Job submitted, waiting for completion...
+    print "Waiting" | "Job submitted, waiting for completion..."
     
     # Wait 2 seconds
     wait 2s
@@ -616,19 +616,19 @@ sequence DataDrivenTest
     var config = run readJson ./test-config.json
     
     # Access properties
-    print Config | Using API: {{config.baseUrl}}
+    print "Config" | "Using API: {{config.baseUrl}}"
     
     # Use in requests
     GET {{config.baseUrl}}/users/{{config.testUser.id}}
     
     # Access nested values and arrays
-    print First Role | {{config.testUser.roles[0]}}
+    print "First Role" | "{{config.testUser.roles[0]}}"
     
     # Modify loaded data inline
     config.baseUrl = https://api.updated.com
     config.testUser.name = Updated Name
     
-    print Updated | New URL: {{config.baseUrl}}
+    print "Updated" | "New URL: {{config.baseUrl}}"
 end sequence
 ```
 
@@ -674,7 +674,7 @@ sequence DatabaseQuery
     var dbResult = run powershell ./scripts/query-db.ps1
     
     # Access properties from the JSON output
-    print User Found | ID: {{dbResult.id}}, Name: {{dbResult.name}}
+    print "User Found" | "ID: {{dbResult.id}}, Name: {{dbResult.name}}"
     
     # Use in requests
     GET https://api.example.com/users/{{dbResult.id}}
@@ -697,18 +697,18 @@ Add debug output to your sequences:
 
 ```bash
 sequence DebugFlow
-    print Starting authentication...
+    print "Starting authentication..."
     
     POST https://api.example.com/login
     Content-Type: application/json
     {"user": "admin"}
     
     var token = $1.token
-    print Token received | Value: {{token}}
+    print "Token received" | "Value: {{token}}"
 end sequence
 ```
 
-Use `print Title | Body content` for expandable messages in the result view.
+Use `print "Title" | "Body content"` for expandable messages in the result view.
 
 ## CLI Usage
 
@@ -942,8 +942,8 @@ end sequence
 | `var x = run js ./script.js` | Run script and capture output |
 | `var data = run readJson ./file.json` | Load JSON file into variable |
 | `data.property = value` | Update loaded JSON property |
-| `print Message` | Print a message |
-| `print Title \| Body` | Print with expandable body |
+| `print "Message"` | Print a message |
+| `print "Title" \| "Body"` | Print with expandable body |
 
 ### Environments (.nornenv)
 

package/dist/cli.js

@@ -12216,11 +12216,12 @@ function findUnquotedPipe(str) {
   }
   return -1;
 }
-function resolveValue(expr, responses, variables, getValueByPath2) {
+function resolveValue(expr, responses, variables, getValueByPath2, responseIndexToVariable) {
   const trimmed = expr.trim();
   const refMatch = trimmed.match(/^\$(\d+)\.(.+)$/);
   if (refMatch) {
-    const responseIndex = parseInt(refMatch[1], 10) - 1;
+    const responseIdx = parseInt(refMatch[1], 10);
+    const responseIndex = responseIdx - 1;
     const path4 = refMatch[2];
     if (responseIndex < 0 || responseIndex >= responses.length) {
       return {
@@ -12228,8 +12229,15 @@ function resolveValue(expr, responses, variables, getValueByPath2) {
         error: `Response $${refMatch[1]} does not exist (only ${responses.length} responses so far)`
       };
     }
-    const value = getValueByPath2(responses[responseIndex], path4);
-    return { value };
+    const response = responses[responseIndex];
+    const value = getValueByPath2(response, path4);
+    return {
+      value,
+      responseIndex: responseIdx,
+      response,
+      jsonPath: path4,
+      variableName: responseIndexToVariable?.get(responseIdx)
+    };
   }
   if (/^\$\d+$/.test(trimmed)) {
     return {
@@ -12246,14 +12254,20 @@ function resolveValue(expr, responses, variables, getValueByPath2) {
       if (typeof varValue === "object" && varValue !== null) {
         const path4 = pathPart.replace(/^\./, "");
         const value = getNestedValue2(varValue, path4);
-        return { value };
+        const isHttpResponse = "status" in varValue && "body" in varValue;
+        return {
+          value,
+          variableName: varName,
+          jsonPath: path4,
+          response: isHttpResponse ? varValue : void 0
+        };
       }
       if (typeof varValue === "string") {
         try {
           const parsed = JSON.parse(varValue);
           const path4 = pathPart.replace(/^\./, "");
           const value = getNestedValue2(parsed, path4);
-          return { value };
+          return { value, variableName: varName, jsonPath: path4 };
         } catch {
           return { value: void 0, error: `Cannot access path on non-object variable: ${varName}` };
         }
@@ -12317,8 +12331,14 @@ function getNestedValue2(obj, path4) {
   }
   return current;
 }
-function evaluateAssertion(assertion, responses, variables, getValueByPath2) {
-  const leftResult = resolveValue(assertion.leftExpr, responses, variables, getValueByPath2);
+function evaluateAssertion(assertion, responses, variables, getValueByPath2, responseIndexToVariable) {
+  const leftResult = resolveValue(assertion.leftExpr, responses, variables, getValueByPath2, responseIndexToVariable);
+  const buildFailureContext = () => ({
+    responseIndex: leftResult.responseIndex,
+    friendlyName: leftResult.variableName,
+    relatedResponse: leftResult.response,
+    jsonPath: leftResult.jsonPath
+  });
   if (leftResult.error) {
     return {
       passed: false,
@@ -12328,28 +12348,33 @@ function evaluateAssertion(assertion, responses, variables, getValueByPath2) {
       leftValue: void 0,
       leftExpression: assertion.leftExpr,
       rightExpression: assertion.rightExpr,
-      error: leftResult.error
+      error: leftResult.error,
+      ...buildFailureContext()
     };
   }
   const leftValue = leftResult.value;
   if (assertion.operator === "exists") {
+    const passed2 = leftValue !== void 0 && leftValue !== null;
     return {
-      passed: leftValue !== void 0 && leftValue !== null,
+      passed: passed2,
       expression: formatExpression(assertion),
       message: assertion.message,
       operator: assertion.operator,
       leftValue,
-      leftExpression: assertion.leftExpr
+      leftExpression: assertion.leftExpr,
+      ...!passed2 ? buildFailureContext() : {}
     };
   }
   if (assertion.operator === "!exists") {
+    const passed2 = leftValue === void 0 || leftValue === null;
     return {
-      passed: leftValue === void 0 || leftValue === null,
+      passed: passed2,
       expression: formatExpression(assertion),
       message: assertion.message,
       operator: assertion.operator,
       leftValue,
-      leftExpression: assertion.leftExpr
+      leftExpression: assertion.leftExpr,
+      ...!passed2 ? buildFailureContext() : {}
     };
   }
   if (!assertion.rightExpr) {
@@ -12360,7 +12385,8 @@ function evaluateAssertion(assertion, responses, variables, getValueByPath2) {
       operator: assertion.operator,
       leftValue,
       leftExpression: assertion.leftExpr,
-      error: `Operator ${assertion.operator} requires a right-hand value`
+      error: `Operator ${assertion.operator} requires a right-hand value`,
+      ...buildFailureContext()
     };
   }
   if (assertion.operator === "isType") {
@@ -12373,18 +12399,20 @@ function evaluateAssertion(assertion, responses, variables, getValueByPath2) {
     } else {
       actualType = typeof leftValue;
     }
+    const passed2 = actualType === expectedType;
     return {
-      passed: actualType === expectedType,
+      passed: passed2,
       expression: formatExpression(assertion),
       message: assertion.message,
       operator: assertion.operator,
       leftValue,
       rightValue: expectedType,
       leftExpression: assertion.leftExpr,
-      rightExpression: assertion.rightExpr
+      rightExpression: assertion.rightExpr,
+      ...!passed2 ? buildFailureContext() : {}
     };
   }
-  const rightResult = resolveValue(assertion.rightExpr, responses, variables, getValueByPath2);
+  const rightResult = resolveValue(assertion.rightExpr, responses, variables, getValueByPath2, responseIndexToVariable);
   if (rightResult.error) {
     return {
       passed: false,
@@ -12395,7 +12423,8 @@ function evaluateAssertion(assertion, responses, variables, getValueByPath2) {
       rightValue: void 0,
       leftExpression: assertion.leftExpr,
       rightExpression: assertion.rightExpr,
-      error: rightResult.error
+      error: rightResult.error,
+      ...buildFailureContext()
     };
   }
   const rightValue = rightResult.value;
@@ -12449,7 +12478,8 @@ function evaluateAssertion(assertion, responses, variables, getValueByPath2) {
           rightValue,
           leftExpression: assertion.leftExpr,
           rightExpression: assertion.rightExpr,
-          error: `Invalid regex pattern: ${rightValue}`
+          error: `Invalid regex pattern: ${rightValue}`,
+          ...buildFailureContext()
         };
       }
       break;
@@ -12462,7 +12492,8 @@ function evaluateAssertion(assertion, responses, variables, getValueByPath2) {
     leftValue,
     rightValue,
     leftExpression: assertion.leftExpr,
-    rightExpression: assertion.rightExpr
+    rightExpression: assertion.rightExpr,
+    ...!passed ? buildFailureContext() : {}
   };
 }
 function formatExpression(assertion) {
@@ -13493,6 +13524,10 @@ async function resolveImports(text, baseDir, readFile2, alreadyImported = /* @__
   const resolvedPaths = [];
   const headerGroups = [];
   const endpoints = [];
+  const headerGroupSources = /* @__PURE__ */ new Map();
+  const endpointSources = /* @__PURE__ */ new Map();
+  const namedRequestSources = /* @__PURE__ */ new Map();
+  const sequenceSources = /* @__PURE__ */ new Map();
   for (const imp of imports) {
     const path4 = await import("path");
     const absolutePath = path4.resolve(baseDir, imp.path);
@@ -13510,16 +13545,64 @@ async function resolveImports(text, baseDir, readFile2, alreadyImported = /* @__
       resolvedPaths.push(absolutePath);
       if (imp.path.endsWith(".nornapi")) {
         const apiDef = parseNornApiFile(content);
-        headerGroups.push(...apiDef.headerGroups);
-        endpoints.push(...apiDef.endpoints);
+        for (const group of apiDef.headerGroups) {
+          const existingSource = headerGroupSources.get(group.name);
+          if (existingSource) {
+            errors.push({
+              path: imp.path,
+              error: `Duplicate header group '${group.name}': already defined in '${existingSource}'`,
+              lineNumber: imp.lineNumber
+            });
+          } else {
+            headerGroupSources.set(group.name, imp.path);
+            headerGroups.push(group);
+          }
+        }
+        for (const endpoint of apiDef.endpoints) {
+          const existingSource = endpointSources.get(endpoint.name);
+          if (existingSource) {
+            errors.push({
+              path: imp.path,
+              error: `Duplicate endpoint '${endpoint.name}': already defined in '${existingSource}'`,
+              lineNumber: imp.lineNumber
+            });
+          } else {
+            endpointSources.set(endpoint.name, imp.path);
+            endpoints.push(endpoint);
+          }
+        }
         continue;
       }
       const importDir = path4.dirname(absolutePath);
       const nestedResult = await resolveImports(content, importDir, readFile2, alreadyImported);
       errors.push(...nestedResult.errors);
       resolvedPaths.push(...nestedResult.resolvedPaths);
-      headerGroups.push(...nestedResult.headerGroups);
-      endpoints.push(...nestedResult.endpoints);
+      for (const group of nestedResult.headerGroups) {
+        const existingSource = headerGroupSources.get(group.name);
+        if (existingSource) {
+          errors.push({
+            path: imp.path,
+            error: `Duplicate header group '${group.name}': already defined in '${existingSource}'`,
+            lineNumber: imp.lineNumber
+          });
+        } else {
+          headerGroupSources.set(group.name, imp.path);
+          headerGroups.push(group);
+        }
+      }
+      for (const endpoint of nestedResult.endpoints) {
+        const existingSource = endpointSources.get(endpoint.name);
+        if (existingSource) {
+          errors.push({
+            path: imp.path,
+            error: `Duplicate endpoint '${endpoint.name}': already defined in '${existingSource}'`,
+            lineNumber: imp.lineNumber
+          });
+        } else {
+          endpointSources.set(endpoint.name, imp.path);
+          endpoints.push(endpoint);
+        }
+      }
       if (nestedResult.importedContent) {
         importedContents.push(nestedResult.importedContent);
       }
@@ -13527,15 +13610,37 @@ async function resolveImports(text, baseDir, readFile2, alreadyImported = /* @__
       const importedNamedRequests = extractNamedRequests(content);
       const importedSequences = extractSequencesFromText(content);
       for (const req of importedNamedRequests) {
-        const resolvedContent = substituteVariables(req.content, importedVariables);
-        importedContents.push(`[${req.name}]
+        const lowerName = req.name.toLowerCase();
+        const existingSource = namedRequestSources.get(lowerName);
+        if (existingSource) {
+          errors.push({
+            path: imp.path,
+            error: `Duplicate named request '${req.name}': already defined in '${existingSource}'`,
+            lineNumber: imp.lineNumber
+          });
+        } else {
+          namedRequestSources.set(lowerName, imp.path);
+          const resolvedContent = substituteVariables(req.content, importedVariables);
+          importedContents.push(`[${req.name}]
 ${resolvedContent}`);
+        }
       }
       for (const seq of importedSequences) {
-        const resolvedContent = substituteVariables(seq.content, importedVariables);
-        importedContents.push(`sequence ${seq.name}
+        const lowerName = seq.name.toLowerCase();
+        const existingSource = sequenceSources.get(lowerName);
+        if (existingSource) {
+          errors.push({
+            path: imp.path,
+            error: `Duplicate sequence '${seq.name}': already defined in '${existingSource}'`,
+            lineNumber: imp.lineNumber
+          });
+        } else {
+          sequenceSources.set(lowerName, imp.path);
+          const resolvedContent = substituteVariables(seq.content, importedVariables);
+          importedContents.push(`sequence ${seq.name}
 ${resolvedContent}
 end sequence`);
+        }
       }
     } catch (error) {
       errors.push({
@@ -20921,6 +21026,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
     responses.push(response);
     runtimeVariables[`$${responses.length}`] = response;
   };
+  const responseIndexToVariable = /* @__PURE__ */ new Map();
   const steps = extractStepsFromSequence(sequenceContent);
   const captures = extractCaptureDirectives(sequenceContent);
   const totalSteps = steps.length;
@@ -20987,7 +21093,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           duration: Date.now() - startTime
         };
       }
-      const result = evaluateAssertion(parsed, responses, runtimeVariables, getValueByPath);
+      const result = evaluateAssertion(parsed, responses, runtimeVariables, getValueByPath, responseIndexToVariable);
       assertionResults.push(result);
       const stepResult = {
         type: "assertion",
@@ -21284,13 +21390,15 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
         const requestParsed = parserHttpRequest(requestText, runtimeVariables);
         const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar) : await sendRequest(requestParsed);
         addResponse(response);
+        responseIndexToVariable.set(responses.length, parsed.varName);
         runtimeVariables[parsed.varName] = response;
         const stepResult = {
           type: "request",
           stepIndex: stepIdx,
           response,
           requestMethod: parsed.method,
-          requestUrl: resolvedUrl
+          requestUrl: resolvedUrl,
+          variableName: parsed.varName
         };
         orderedSteps.push(stepResult);
         reportProgress(stepIdx, "request", `var ${parsed.varName} = ${requestDescription}`, stepResult);
@@ -22223,7 +22331,11 @@ function formatAssertion(assertion, options) {
   const { colors, verbose } = options;
   const lines = [];
   const icon = assertion.passed ? colors.checkmark : colors.cross;
-  const displayMessage = assertion.message || assertion.expression;
+  let displayExpr = assertion.expression;
+  if (assertion.friendlyName && assertion.responseIndex) {
+    displayExpr = displayExpr.replace("$" + assertion.responseIndex, assertion.friendlyName);
+  }
+  const displayMessage = assertion.message || displayExpr;
   lines.push(`${icon} assert ${displayMessage}`);
   if (!assertion.passed || verbose) {
     if (assertion.error) {
@@ -23403,9 +23515,22 @@ async function main() {
       workingDir,
       async (importPath) => fsPromises.readFile(importPath, "utf-8")
     );
-    for (const err of importResult.errors) {
+    const duplicateErrors = importResult.errors.filter(
+      (err) => err.error.includes("Duplicate header group") || err.error.includes("Duplicate endpoint") || err.error.includes("Duplicate named request") || err.error.includes("Duplicate sequence")
+    );
+    const otherErrors = importResult.errors.filter(
+      (err) => !err.error.includes("Duplicate header group") && !err.error.includes("Duplicate endpoint") && !err.error.includes("Duplicate named request") && !err.error.includes("Duplicate sequence")
+    );
+    for (const err of otherErrors) {
       console.error(colors.warning(`Import warning: ${err.path} - ${err.error}`));
     }
+    if (duplicateErrors.length > 0) {
+      console.error(colors.error("Cannot execute - duplicate definitions found:"));
+      for (const err of duplicateErrors) {
+        console.error(colors.error(`  ${err.path}: ${err.error}`));
+      }
+      process.exit(1);
+    }
     const fileContentWithImports = importResult.importedContent ? `${importResult.importedContent}
 
 ${fileContent}` : fileContent;
@@ -23512,9 +23637,22 @@ ${fileContent}` : fileContent;
       workingDir,
       async (importPath) => fsPromises.readFile(importPath, "utf-8")
     );
-    for (const err of importResult.errors) {
+    const duplicateErrors2 = importResult.errors.filter(
+      (err) => err.error.includes("Duplicate header group") || err.error.includes("Duplicate endpoint") || err.error.includes("Duplicate named request") || err.error.includes("Duplicate sequence")
+    );
+    const otherErrors2 = importResult.errors.filter(
+      (err) => !err.error.includes("Duplicate header group") && !err.error.includes("Duplicate endpoint") && !err.error.includes("Duplicate named request") && !err.error.includes("Duplicate sequence")
+    );
+    for (const err of otherErrors2) {
       console.error(colors.warning(`Import warning: ${err.path} - ${err.error}`));
     }
+    if (duplicateErrors2.length > 0) {
+      console.error(colors.error("Cannot execute - duplicate definitions found:"));
+      for (const err of duplicateErrors2) {
+        console.error(colors.error(`  ${err.path}: ${err.error}`));
+      }
+      process.exit(1);
+    }
     const fileContentWithImports = importResult.importedContent ? `${importResult.importedContent}
 
 ${fileContent}` : fileContent;

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.2.2",
+  "version": "1.2.4",
   "publisher": "Norn-PeterKrustanov",
   "author": {
     "name": "Peter Krastanov"