norn-cli 1.10.1 → 1.10.2

package/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to the "Norn" extension will be documented in this file.
 
 ## [Unreleased]
 
+## [1.10.2] - 2026-03-15
+
+### Fixed
+- **Sequence Return + Response Panel UX**:
+  - Fixed `var result = run SomeSequence` so single-value returns can capture literal values like `return "Bar"` instead of resolving to empty output.
+  - Fixed streaming/final response panel step timers so print/SQL rows show per-step duration instead of elapsed-from-start totals.
+  - Fixed the streaming step counter so hidden `wait` steps no longer inflate the top-bar step total.
+  - Fixed `.norn` syntax highlighting so quoted string literals after `return` use normal string coloring.
+
+- **Request Parsing + CLI Error Output**:
+  - Fixed request parsing to stop bodies at the next Norn block boundary, preventing later named requests or sequence declarations from leaking into request bodies.
+  - Fixed CLI text and HTML reports to preserve multiline request/sequence error details instead of collapsing them into single-line output.
+
+- **API Coverage + Import UX**:
+  - Fixed API coverage to follow status assertions on captured request variables and named requests that call `.nornapi` endpoints.
+  - Fixed the OpenAPI import section picker so selecting `All` stays mutually exclusive with individual section selections.
+
 ## [1.7.0] - 2026-03-07
 
 ### Added

package/dist/cli.js

@@ -101801,6 +101801,16 @@ function getHeaderGroup(definition, name) {
 function getEndpoint(definition, name) {
   return definition.endpoints.find((ep) => ep.name === name);
 }
+function resolveEndpointPath(endpoint, params) {
+  let resolvedPath = endpoint.path;
+  for (const paramName of endpoint.parameters) {
+    const value = params[paramName];
+    if (value !== void 0) {
+      resolvedPath = resolvedPath.replace(`{${paramName}}`, value);
+    }
+  }
+  return resolvedPath;
+}
 function resolveHeaderValues(headerGroup, variables) {
   const resolved = {};
   for (const [name, value] of Object.entries(headerGroup.headers)) {
@@ -102283,7 +102293,7 @@ function extractNamedRequests(text) {
       let endLine = lines.length - 1;
       for (let j = contentStartLine; j < lines.length; j++) {
         const scanLine = lines[j].trim();
-        if (scanLine.match(/^\[/) || scanLine.match(/^sequence\s+/) || scanLine.startsWith("###")) {
+        if (isNamedRequestDeclarationLine(scanLine) || isSequenceStartDeclaration(scanLine) || isSequenceEndDeclaration(scanLine) || scanLine.startsWith("###")) {
           endLine = j - 1;
           break;
         }
@@ -102499,10 +102509,9 @@ function parserHttpRequest(text, variables = {}) {
   let body;
   if (bodyStartIndex > 0) {
     const bodyLines = [];
-    const boundaryRegex = /^\[.*\]$|^sequence\s+|^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i;
     for (let i = bodyStartIndex; i < allLines.length; i++) {
       const line2 = allLines[i].trim();
-      if (boundaryRegex.test(line2)) {
+      if (isRequestLine(line2) || isNamedRequestDeclarationLine(line2) || isSequenceLine(line2) || isEndSequenceLine(line2) || line2.startsWith("###")) {
         break;
       }
       if (line2 && !line2.startsWith("#") && !line2.startsWith("var ")) {
@@ -102516,6 +102525,19 @@ function parserHttpRequest(text, variables = {}) {
   }
   return { method: method.toUpperCase(), url: url2, headers, body, retryCount, backoffMs };
 }
+var METHOD_REGEX = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS|TRACE|CONNECT)\s+/i;
+function isRequestLine(line2) {
+  return METHOD_REGEX.test(line2.trim());
+}
+function isSequenceLine(line2) {
+  return isSequenceStartDeclaration(line2.trim());
+}
+function isNamedRequestDeclarationLine(line2) {
+  return /^\[[^\]]+\]\s*$/.test(line2.trim());
+}
+function isEndSequenceLine(line2) {
+  return isSequenceEndDeclaration(line2.trim());
+}
 function extractImports(text) {
   const lines = text.split("\n");
   const imports = [];
@@ -110280,6 +110302,10 @@ function resolveReturnExpression(expr, runtimeVariables) {
     return { key: varName, value: varValue };
   }
 }
+function resolveSingleReturnValue(expr, runtimeVariables) {
+  const result = evaluateSqlArgumentExpression(expr, runtimeVariables);
+  return result.error ? "" : result.value;
+}
 function extractReturnVariables(content) {
   const lines = content.split("\n");
   for (const line2 of lines) {
@@ -110289,6 +110315,54 @@ function extractReturnVariables(content) {
   }
   return null;
 }
+function buildParsedNamedRequest(requestContent, runtimeVariables, apiDefinitions) {
+  if (apiDefinitions && apiDefinitions.endpoints.length > 0 && isApiRequestLine(requestContent, apiDefinitions.endpoints)) {
+    const apiRequest = parseApiRequest(
+      requestContent,
+      apiDefinitions.endpoints,
+      apiDefinitions.headerGroups
+    );
+    if (apiRequest) {
+      const endpoint = getEndpoint(apiDefinitions, apiRequest.endpointName);
+      if (!endpoint) {
+        throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
+      }
+      const resolvedParams = {};
+      for (const [paramName, paramValue] of Object.entries(apiRequest.params)) {
+        if (runtimeVariables[paramValue] !== void 0) {
+          resolvedParams[paramName] = String(runtimeVariables[paramValue]);
+        } else {
+          resolvedParams[paramName] = substituteVariables(paramValue, runtimeVariables);
+        }
+      }
+      const resolvedPath = substituteVariables(
+        resolveEndpointPath(endpoint, resolvedParams),
+        runtimeVariables
+      );
+      const combinedHeaders = {};
+      for (const groupName of apiRequest.headerGroupNames) {
+        const group = getHeaderGroup(apiDefinitions, groupName);
+        if (group) {
+          Object.assign(combinedHeaders, resolveHeaderValues(group, runtimeVariables));
+        }
+      }
+      for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
+        combinedHeaders[headerName] = substituteVariables(headerValue, runtimeVariables);
+      }
+      return {
+        method: apiRequest.method,
+        url: resolvedPath,
+        headers: combinedHeaders,
+        body: apiRequest.body ? substituteVariables(apiRequest.body, runtimeVariables) : void 0
+      };
+    }
+  }
+  let parsed = parserHttpRequest(requestContent, runtimeVariables);
+  if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
+    parsed = applyHeaderGroupsToRequest(parsed, requestContent, apiDefinitions.headerGroups, runtimeVariables);
+  }
+  return parsed;
+}
 function parseRunArguments(argsStr) {
   const args = [];
   if (!argsStr || !argsStr.trim()) {
@@ -111662,6 +111736,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
     for (let stepIdx = 0; stepIdx < steps.length; stepIdx++) {
       const step = steps[stepIdx];
       await emitBeforeStep(step, stepIdx);
+      const stepStartTime = Date.now();
       try {
         if (step.type === "if") {
           if (shouldSkip()) {
@@ -111672,6 +111747,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
             const stepResult = {
               type: "print",
               stepIndex: stepIdx,
+              durationMs: Date.now() - stepStartTime,
               print: {
                 title: `if ${step.content}: ${conditionMet ? "true" : "false"}`,
                 timestamp: Date.now() - startTime
@@ -111713,6 +111789,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           const stepResult = {
             type: "assertion",
             stepIndex: stepIdx,
+            durationMs: Date.now() - stepStartTime,
             assertion: result,
             lineNumber: step.lineNumber
           };
@@ -111721,13 +111798,6 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           reportProgress(stepIdx, "assertion", `${statusIcon} assert ${result.expression}`, stepResult);
           if (!result.passed) {
             const failMessage = result.message ? `Assertion failed: ${result.message}` : `Assertion failed: ${result.expression}`;
-            errors.push(failMessage);
-            if (result.error) {
-              errors.push(`  Error: ${result.error}`);
-            } else {
-              errors.push(`  Expected: ${result.rightExpression ?? result.operator}`);
-              errors.push(`  Actual: ${JSON.stringify(result.leftValue)}`);
-            }
             await emitFailure(failMessage, step, stepIdx);
             return {
               name: "",
@@ -111751,6 +111821,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           const stepResult = {
             type: "print",
             stepIndex: stepIdx,
+            durationMs: Date.now() - stepStartTime,
             print: {
               title,
               body,
@@ -111768,6 +111839,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           const stepResult = {
             type: "print",
             stepIndex: stepIdx,
+            durationMs: Date.now() - stepStartTime,
             print: {
               title: `Waited ${durationMs >= 1e3 ? durationMs / 1e3 + "s" : durationMs + "ms"}`,
               timestamp: Date.now() - startTime
@@ -111796,6 +111868,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           const stepResult = {
             type: "json",
             stepIndex: stepIdx,
+            durationMs: Date.now() - stepStartTime,
             json: {
               varName: parsed.varName,
               filePath: result.filePath,
@@ -112074,6 +112147,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
             const stepResult = {
               type: "sql",
               stepIndex: stepIdx,
+              durationMs: Date.now() - stepStartTime,
               sql: sqlResult,
               variableName: parsed.variableName,
               lineNumber: step.lineNumber
@@ -112479,60 +112553,7 @@ ${indentMultiline(userMessage)}`;
           let requestUrl = "";
           let requestMethod = "";
           try {
-            let requestParsed;
-            if (apiDefinitions && apiDefinitions.endpoints.length > 0 && isApiRequestLine(namedRequest.content, apiDefinitions.endpoints)) {
-              const apiRequest = parseApiRequest(
-                namedRequest.content,
-                apiDefinitions.endpoints,
-                apiDefinitions.headerGroups
-              );
-              if (apiRequest) {
-                const endpoint = getEndpoint(
-                  { headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints },
-                  apiRequest.endpointName
-                );
-                if (endpoint) {
-                  let resolvedPath = substituteVariables(endpoint.path, runtimeVariables);
-                  for (const [paramName, paramValue] of Object.entries(apiRequest.params)) {
-                    let resolvedValue = paramValue;
-                    if (runtimeVariables[paramValue] !== void 0) {
-                      resolvedValue = String(runtimeVariables[paramValue]);
-                    } else {
-                      resolvedValue = substituteVariables(paramValue, runtimeVariables);
-                    }
-                    resolvedPath = resolvedPath.replace(`{${paramName}}`, resolvedValue);
-                  }
-                  const combinedHeaders = {};
-                  for (const groupName of apiRequest.headerGroupNames) {
-                    const group = getHeaderGroup(apiDefinitions, groupName);
-                    if (group) {
-                      const resolvedHeaders = resolveHeaderValues(group, runtimeVariables);
-                      Object.assign(combinedHeaders, resolvedHeaders);
-                    }
-                  }
-                  for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
-                    const resolved = substituteVariables(headerValue, runtimeVariables);
-                    combinedHeaders[headerName] = resolved;
-                  }
-                  const bodyParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
-                  requestParsed = {
-                    method: apiRequest.method,
-                    url: resolvedPath,
-                    headers: combinedHeaders,
-                    body: bodyParsed.body
-                  };
-                } else {
-                  throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
-                }
-              } else {
-                requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
-              }
-            } else {
-              requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
-              if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
-                requestParsed = applyHeaderGroupsToRequest(requestParsed, namedRequest.content, apiDefinitions.headerGroups, runtimeVariables);
-              }
-            }
+            const requestParsed = buildParsedNamedRequest(namedRequest.content, runtimeVariables, apiDefinitions);
             requestUrl = requestParsed.url;
             requestMethod = requestParsed.method;
             validatePreparedRequest(
@@ -112642,7 +112663,7 @@ ${indentMultiline(userMessage)}`;
             let requestUrl = "";
             let requestMethod = "";
             try {
-              const requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
+              const requestParsed = buildParsedNamedRequest(namedRequest.content, runtimeVariables, apiDefinitions);
               requestUrl = requestParsed.url;
               requestMethod = requestParsed.method;
               validatePreparedRequest(
@@ -112802,12 +112823,7 @@ ${indentMultiline(userMessage)}`;
           const returnExpressions = extractReturnVariables(targetSequence.content);
           if (returnExpressions && returnExpressions.length > 0 && subResult.variables) {
             if (returnExpressions.length === 1) {
-              const resolved = resolveReturnExpression(returnExpressions[0], subResult.variables);
-              if (resolved) {
-                runtimeVariables[varName] = resolved.value;
-              } else {
-                runtimeVariables[varName] = "";
-              }
+              runtimeVariables[varName] = resolveSingleReturnValue(returnExpressions[0], subResult.variables);
             } else {
               const returnedObj = {};
               for (const expr of returnExpressions) {
@@ -113414,7 +113430,14 @@ function formatSequenceResult(result, options) {
     lines.push("");
     lines.push(colors.warning("Warnings/Errors:"));
     for (const err of result.errors) {
-      lines.push(`  ${colors.bullet} ${err}`);
+      const errLines = String(err ?? "").split("\n");
+      if (errLines.length === 0) {
+        continue;
+      }
+      lines.push(`  ${colors.bullet} ${errLines[0]}`);
+      for (const line2 of errLines.slice(1)) {
+        lines.push(`    ${line2}`);
+      }
     }
   }
   return lines;
@@ -113976,7 +113999,7 @@ function generateErrorsHtml(errors, redaction) {
         <div class="errors">
             <h4>Errors</h4>
             <ul>
-                ${errors.map((e) => `<li>${escapeHtml(redactString(e, redaction))}</li>`).join("\n")}
+                ${errors.map((e) => `<li>${escapeHtml(redactString(e, redaction)).replace(/\n/g, "<br>")}</li>`).join("\n")}
             </ul>
         </div>`;
 }

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