norn-cli 1.3.7 → 1.3.9

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to the "Norn" extension will be documented in this file.
 
+## [1.3.9] - 2026-02-09
+
+### Added
+- **`pwsh` Script Type**: Added `pwsh` as an alias for `powershell` in script commands
+  - `var x = run pwsh "./script.ps1"` now works alongside `run powershell`
+- **Bare Variable Support in Property Assignments**: Variables can be assigned without `{{}}` syntax
+  - `payload.userId = dynamicUserId` now works (previously required `{{dynamicUserId}}`)
+- **Request Body in Verbose Output**: CLI `-v` flag now shows the actual request body and headers sent
+  - Helps debug payload issues by showing exactly what was transmitted
+
+### Fixed
+- **Script Output Capture**: Fixed variable shadowing bug that could affect JSON parsing of script output
+
+## [1.3.8] - 2026-02-09
+
+### Fixed
+- **Named Requests with Endpoint Syntax**: Fixed `run RequestName` failing when the named request uses `.nornapi` endpoint syntax
+  - `[PostFormWithEndpoint]` with `POST HttpBinPost Form` now works correctly when invoked via `run PostFormWithEndpoint`
+  - Endpoint is resolved and headers/body are properly applied
+
 ## [1.3.7] - 2026-02-09
 
 ### Fixed

package/dist/cli.js

@@ -26192,6 +26192,8 @@ async function sendRequestWithJar(request, jar, retryOptions) {
     let currentMethod = request.method;
     let currentBody = request.body;
     let finalResponse = null;
+    let sentRequestBody = void 0;
+    let sentRequestHeaders = {};
     try {
       while (redirectCount <= maxRedirects) {
         const existingCookies = await jar.getCookies(currentUrl);
@@ -26238,6 +26240,8 @@ async function sendRequestWithJar(request, jar, retryOptions) {
             }
           }
         }
+        sentRequestBody = data;
+        sentRequestHeaders = { ...headers };
         const response = await axios_default({
           method: currentMethod,
           url: currentUrl,
@@ -26290,7 +26294,9 @@ async function sendRequestWithJar(request, jar, retryOptions) {
         headers: finalResponse.headers,
         body: finalResponse.data,
         duration: Date.now() - startTime,
-        cookies
+        cookies,
+        requestBody: sentRequestBody,
+        requestHeaders: sentRequestHeaders
       };
       if (attemptsMade > 1 || totalAttempts > 1) {
         result.retryInfo = {
@@ -26453,23 +26459,25 @@ function isPwshAvailable() {
 }
 function parseRunCommand(line2) {
   const trimmed = line2.trim();
-  const captureMatch = trimmed.match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*run\s+(bash|powershell|js)\s+(.+)$/i);
+  const captureMatch = trimmed.match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*run\s+(bash|powershell|pwsh|js)\s+(.+)$/i);
   if (captureMatch) {
     const [, varName, type, rest] = captureMatch;
     const { scriptPath, args } = parsePathAndArgs(rest);
+    const normalizedType = type.toLowerCase() === "pwsh" ? "powershell" : type.toLowerCase();
     return {
-      type: type.toLowerCase(),
+      type: normalizedType,
       scriptPath,
       args,
       captureAs: varName
     };
   }
-  const runMatch = trimmed.match(/^run\s+(bash|powershell|js)\s+(.+)$/i);
+  const runMatch = trimmed.match(/^run\s+(bash|powershell|pwsh|js)\s+(.+)$/i);
   if (runMatch) {
     const [, type, rest] = runMatch;
     const { scriptPath, args } = parsePathAndArgs(rest);
+    const normalizedType = type.toLowerCase() === "pwsh" ? "powershell" : type.toLowerCase();
     return {
-      type: type.toLowerCase(),
+      type: normalizedType,
       scriptPath,
       args
     };
@@ -26507,7 +26515,7 @@ function parsePathAndArgs(rest) {
 }
 function isRunCommand(line2) {
   const trimmed = line2.trim();
-  return /^(var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+(bash|powershell|js)\s+/i.test(trimmed);
+  return /^(var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+(bash|powershell|pwsh|js)\s+/i.test(trimmed);
 }
 async function runScript(type, scriptPath, args, workingDir, variables = {}, captureVar) {
   const startTime = Date.now();
@@ -28021,9 +28029,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
       continue;
     }
     if (step.type === "propAssign") {
-      const bareResolved = resolveBareVariables(step.content, runtimeVariables);
-      const substitutedContent = substituteVariables(bareResolved, runtimeVariables);
-      const parsed = parsePropertyAssignment(substitutedContent);
+      const parsed = parsePropertyAssignment(step.content);
       if (!parsed) {
         errors.push(`Step ${stepIdx + 1}: Invalid property assignment: ${step.content}`);
         return {
@@ -28066,9 +28072,11 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           duration: Date.now() - startTime
         };
       }
-      let newValue = parsed.value;
+      const bareResolvedValue = resolveBareVariables(parsed.value, runtimeVariables);
+      const resolvedValue = substituteVariables(bareResolvedValue, runtimeVariables);
+      let newValue = resolvedValue;
       try {
-        newValue = JSON.parse(parsed.value);
+        newValue = JSON.parse(resolvedValue);
       } catch {
       }
       const success = setNestedValue(jsonObj, parsed.propertyPath, newValue);
@@ -28305,9 +28313,9 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
         if (parsed.captureAs) {
           let outputValue = result.output;
           try {
-            const parsed2 = JSON.parse(result.output);
-            if (typeof parsed2 === "object" && parsed2 !== null) {
-              outputValue = parsed2;
+            const jsonParsed = JSON.parse(result.output);
+            if (typeof jsonParsed === "object" && jsonParsed !== null) {
+              outputValue = jsonParsed;
             }
           } catch {
           }
@@ -28462,9 +28470,68 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
       let requestUrl = "";
       let requestMethod = "";
       try {
-        let requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
-        if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
-          requestParsed = applyHeaderGroupsToRequest(requestParsed, namedRequest.content, apiDefinitions.headerGroups, runtimeVariables);
+        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 = endpoint.path;
+              resolvedPath = resolvedPath.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
+                return runtimeVariables[varName] !== void 0 ? String(runtimeVariables[varName]) : `{{${varName}}}`;
+              });
+              for (const [paramName, paramValue] of Object.entries(apiRequest.params)) {
+                let resolvedValue = paramValue;
+                if (runtimeVariables[paramValue] !== void 0) {
+                  resolvedValue = String(runtimeVariables[paramValue]);
+                } else if (paramValue.startsWith("{{") && paramValue.endsWith("}}")) {
+                  const varName = paramValue.slice(2, -2);
+                  if (runtimeVariables[varName] !== void 0) {
+                    resolvedValue = String(runtimeVariables[varName]);
+                  }
+                }
+                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)) {
+                let resolved = headerValue;
+                resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
+                  return runtimeVariables[varName] !== void 0 ? String(runtimeVariables[varName]) : `{{${varName}}}`;
+                });
+                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);
+          }
         }
         requestUrl = requestParsed.url;
         requestMethod = requestParsed.method;
@@ -28798,6 +28865,20 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
             parsed = applyHeaderGroupsToRequest(parsed, step.content, apiDefinitions.headerGroups, runtimeVariables);
           }
+          if (parsed.body) {
+            const bodyTrimmed = parsed.body.trim();
+            const bareVarMatch = bodyTrimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)$/);
+            if (bareVarMatch && bareVarMatch[1] in runtimeVariables) {
+              const varValue = runtimeVariables[bareVarMatch[1]];
+              if (typeof varValue === "object" && varValue !== null) {
+                parsed.body = JSON.stringify(varValue);
+              } else if (typeof varValue === "string") {
+                parsed.body = varValue;
+              } else {
+                parsed.body = String(varValue);
+              }
+            }
+          }
         }
         const { retryCount, backoffMs } = extractRetryOptions(step.content);
         const retryOpts = retryCount ?? parsed.retryCount ? {
@@ -29316,11 +29397,13 @@ function formatRequestStep(step, options) {
     colors,
     redaction,
     verbose,
-    showDetails: !isSuccess,
-    // Show request details on failure
+    showDetails: !isSuccess || verbose,
+    // Show request details on failure or verbose
     index: requestIndex,
     method: step.requestMethod,
-    url: step.requestUrl
+    url: step.requestUrl,
+    requestBody: step.response.requestBody,
+    requestHeaders: step.response.requestHeaders
   });
 }
 function formatAssertionStep(step, options) {

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