norn-cli 1.10.1 → 1.10.3

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 = [];
@@ -109438,6 +109460,9 @@ function getConnectionValue(values, ...keys) {
 function getConnectionString(values) {
   return getConnectionValue(values, "connectionString");
 }
+function usesWindowsIntegratedSqlServerAuth(connectionString) {
+  return /(?:^|;)\s*Integrated\s+Security\s*=\s*(?:true|yes|sspi)\s*(?:;|$)/i.test(connectionString) || /(?:^|;)\s*Trusted_Connection\s*=\s*(?:true|yes|sspi)\s*(?:;|$)/i.test(connectionString);
+}
 function buildMissingConnectionError(adapterLabel, profile) {
   return `Missing required ${adapterLabel} connection string. Expected 'connectionString ${profile} = ...' in .nornenv.`;
 }
@@ -109495,7 +109520,7 @@ if ([string]::IsNullOrWhiteSpace($raw)) {
     throw 'Missing SQL adapter payload.'
 }
 
-$payload = $raw | ConvertFrom-Json -Depth 100
+$payload = $raw | ConvertFrom-Json
 $connectionString = [string]$payload.connection.values.connectionString
 if ([string]::IsNullOrWhiteSpace($connectionString)) {
     throw 'Missing SQL Server Integrated Auth connection string.'
@@ -109526,9 +109551,13 @@ $resolveHandler = [System.ResolveEventHandler]{
 $sqlText = [string]$payload.operation.sql
 $mode = [string]$payload.mode
 $paramsObject = $payload.params
+$connectionStringHasUserId = $connectionString -match '(?i)(?:^|;)s*(?:User ID|UID)s*='
+$connectionStringHasPassword = $connectionString -match '(?i)(?:^|;)s*(?:Password|PWD)s*='
 
 $connection = $null
+$connectionBuilder = $null
 try {
+    $connectionBuilder = New-Object Microsoft.Data.SqlClient.SqlConnectionStringBuilder $connectionString
     $connection = New-Object Microsoft.Data.SqlClient.SqlConnection $connectionString
     $command = $connection.CreateCommand()
     $command.CommandText = $sqlText
@@ -109600,18 +109629,97 @@ try {
     $response | ConvertTo-Json -Depth 100 -Compress
 }
 catch {
-    $details = @()
+    $details = New-Object System.Collections.Generic.List[string]
     if ($_.Exception -and $_.Exception.GetType()) {
-        $details += "type: $($_.Exception.GetType().FullName)"
+        $details.Add("type: $($_.Exception.GetType().FullName)")
     }
     if ($_.InvocationInfo -and $_.InvocationInfo.ScriptLineNumber) {
-        $details += "line: $($_.InvocationInfo.ScriptLineNumber)"
+        $details.Add("line: $($_.InvocationInfo.ScriptLineNumber)")
     }
     if ($_.FullyQualifiedErrorId) {
-        $details += "id: $($_.FullyQualifiedErrorId)"
+        $details.Add("id: $($_.FullyQualifiedErrorId)")
+    }
+
+    try {
+        $details.Add("adapter: sqlserver-windows")
+        $details.Add("powershell: $($PSVersionTable.PSVersion)")
+        $details.Add("sqlClientVersion: $(([Microsoft.Data.SqlClient.SqlConnection]).Assembly.GetName().Version)")
+        $details.Add("windowsIdentity: $([System.Security.Principal.WindowsIdentity]::GetCurrent().Name)")
+    } catch {
+    }
+
+    if ($null -ne $connectionBuilder) {
+        if (-not [string]::IsNullOrWhiteSpace([string]$connectionBuilder.DataSource)) {
+            $details.Add("dataSource: $($connectionBuilder.DataSource)")
+        }
+        if (-not [string]::IsNullOrWhiteSpace([string]$connectionBuilder.InitialCatalog)) {
+            $details.Add("database: $($connectionBuilder.InitialCatalog)")
+        }
+        $details.Add("integratedSecurity: $($connectionBuilder.IntegratedSecurity)")
+        $details.Add("encrypt: $($connectionBuilder.Encrypt)")
+        $details.Add("trustServerCertificate: $($connectionBuilder.TrustServerCertificate)")
+        $details.Add("applicationIntent: $($connectionBuilder.ApplicationIntent)")
+        $details.Add("multiSubnetFailover: $($connectionBuilder.MultiSubnetFailover)")
+
+        try {
+            $hostNameInCertificate = [string]$connectionBuilder['HostNameInCertificate']
+            if (-not [string]::IsNullOrWhiteSpace($hostNameInCertificate)) {
+                $details.Add("hostNameInCertificate: $hostNameInCertificate")
+            }
+        } catch {
+        }
+    }
+
+    $details.Add("userIdPresent: $connectionStringHasUserId")
+    $details.Add("passwordPresent: $connectionStringHasPassword")
+
+    $sqlException = $null
+    if ($_.Exception -is [Microsoft.Data.SqlClient.SqlException]) {
+        $sqlException = [Microsoft.Data.SqlClient.SqlException]$_.Exception
+    } elseif ($_.Exception -and $_.Exception.InnerException -is [Microsoft.Data.SqlClient.SqlException]) {
+        $sqlException = [Microsoft.Data.SqlClient.SqlException]$_.Exception.InnerException
+    }
+
+    if ($null -ne $sqlException) {
+        $details.Add("sqlNumber: $($sqlException.Number)")
+        $details.Add("sqlState: $($sqlException.State)")
+        $details.Add("sqlClass: $($sqlException.Class)")
+        if (-not [string]::IsNullOrWhiteSpace([string]$sqlException.Server)) {
+            $details.Add("sqlServer: $($sqlException.Server)")
+        }
+        if (-not [string]::IsNullOrWhiteSpace([string]$sqlException.Procedure)) {
+            $details.Add("sqlProcedure: $($sqlException.Procedure)")
+        }
+        if ($sqlException.LineNumber -gt 0) {
+            $details.Add("sqlLineNumber: $($sqlException.LineNumber)")
+        }
+        if ($sqlException.ClientConnectionId -ne [guid]::Empty) {
+            $details.Add("clientConnectionId: $($sqlException.ClientConnectionId)")
+        }
+        if ($sqlException.Errors -and $sqlException.Errors.Count -gt 0) {
+            $messages = @()
+            foreach ($sqlError in $sqlException.Errors) {
+                if ($sqlError -and -not [string]::IsNullOrWhiteSpace([string]$sqlError.Message)) {
+                    $messages += [string]$sqlError.Message
+                }
+            }
+            if ($messages.Count -gt 0) {
+                $details.Add("sqlErrors: $($messages -join ' | ')")
+            }
+        }
+    }
+
+    if ($_.Exception -and $_.Exception.InnerException) {
+        $details.Add("innerType: $($_.Exception.InnerException.GetType().FullName)")
+        if (-not [string]::IsNullOrWhiteSpace([string]$_.Exception.InnerException.Message)) {
+            $details.Add("innerMessage: $($_.Exception.InnerException.Message)")
+        }
+    }
+
+    [Console]::Error.WriteLine("$($_.Exception.Message)")
+    foreach ($detail in $details) {
+        [Console]::Error.WriteLine("  $detail")
     }
-    $suffix = if ($details.Count -gt 0) { " ($($details -join ', '))" } else { '' }
-    [Console]::Error.WriteLine("$($_.Exception.Message)$suffix")
     exit 1
 }
 finally {
@@ -109772,6 +109880,9 @@ async function runBuiltInSqlServerAdapter(request) {
   if (!connectionString) {
     fail(buildMissingConnectionError("SQL Server", request.connection.profile));
   }
+  if (usesWindowsIntegratedSqlServerAuth(connectionString)) {
+    fail("This SQL Server connection string uses Windows/Integrated authentication. Use adapter 'sqlserver-windows' in norn.sql.json.");
+  }
   const pool = new mssql.ConnectionPool(connectionString);
   try {
     await pool.connect();
@@ -109810,7 +109921,7 @@ async function runBuiltInSqlServerIntegratedAdapter(request) {
   const values = request.connection.values;
   const connectionString = getConnectionString(values);
   if (!connectionString) {
-    fail(buildMissingConnectionError("SQL Server Integrated Auth", request.connection.profile));
+    fail(buildMissingConnectionError("SQL Server (Windows)", request.connection.profile));
   }
   const compiled = compileSqlServerSql(request.operation.sql, request.params || {});
   const compiledRequest = {
@@ -109824,7 +109935,7 @@ async function runBuiltInSqlServerIntegratedAdapter(request) {
   try {
     return await runSqlServerIntegratedViaPowerShell(compiledRequest);
   } catch (error) {
-    throw formatBuiltInDriverError("SQL Server Integrated Auth", error);
+    throw formatBuiltInDriverError("SQL Server (Windows)", error);
   }
 }
 function isBuiltInSqlAdapter(adapterId) {
@@ -110280,6 +110391,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 +110404,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 +111825,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 +111836,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 +111878,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 +111887,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 +111910,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           const stepResult = {
             type: "print",
             stepIndex: stepIdx,
+            durationMs: Date.now() - stepStartTime,
             print: {
               title,
               body,
@@ -111768,6 +111928,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 +111957,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 +112236,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 +112642,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 +112752,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 +112912,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 +113519,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 +114088,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.3",
   "publisher": "Norn-PeterKrustanov",
   "author": {
     "name": "Peter Krastanov"