norn-cli 1.10.4 → 1.10.6

package/AGENTS.md

@@ -2,6 +2,14 @@
 
 These instructions apply to all conversations about the Norn VS Code extension.
 
+## Repo Boundary
+
+These instructions apply only inside `/Users/petercrest/Worktable/Projects/vsApi`.
+
+- Do **not** apply them to standalone work in sibling repos such as `/Users/petercrest/Worktable/Projects/norn_website`.
+- If a task is website-only, prefer the website repo's local instructions instead.
+- Only use these rules for cross-repo work when the task explicitly includes `vsApi`.
+
 ## CLI Support is Mandatory
 
 Every feature implementation must work in both:

package/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to the "Norn" extension will be documented in this file.
 
 ## [Unreleased]
 
+## [1.10.6] - 2026-03-28
+
+### Fixed
+- **Structured Variable Storage**:
+  - Kept structured runtime values as real objects instead of JSON strings so the debugger, assertions, and path access all see the same types.
+  - Preserved compatibility for existing string-backed values when resolving paths.
+
+### Changed
+- **Docs**:
+  - Updated the advanced website docs to note that structured values stay as objects in memory.
+
+## [1.10.5] - 2026-03-28
+
+### Improved
+- **URL-Encoded Request Bodies (Extension + CLI)**:
+  - Added stricter shared validation for `application/x-www-form-urlencoded` request bodies so malformed lines now fail fast with clear preflight errors in both the editor and CLI.
+  - Added support for single-line ampersand-delimited form bodies such as `key1=value1&key2=value2`.
+  - Preserved raw-request header-group workflows by stripping standalone header-group lines from the request body before validation and send.
+
+### Fixed
+- **Imported Parameterized Sequences**:
+  - Fixed `.norn` import resolution so imported helper sequences keep their parameter lists and can be invoked correctly from other files.
+
+- **Form Body Syntax Highlighting**:
+  - Fixed `.norn` syntax coloring so URL-encoded body lines are highlighted correctly after inline headers in raw request blocks.
+
 ## [1.10.4] - 2026-03-21
 
 ### Improved

package/dist/cli.js

@@ -102749,8 +102749,9 @@ ${resolvedContent}`);
           });
         } else {
           sequenceSources.set(lowerName, absolutePath);
+          const resolvedDeclaration = substituteVariables(seq.declaration, importedVariables);
           const resolvedContent = substituteVariables(seq.content, importedVariables);
-          importedContents.push(`sequence ${seq.name}
+          importedContents.push(`${resolvedDeclaration}
 ${resolvedContent}
 end sequence`);
         }
@@ -102781,17 +102782,20 @@ function extractSequencesFromText(text) {
   let currentSequence = null;
   for (let i = 0; i < lines.length; i++) {
     const line2 = lines[i].trim();
-    const sequenceMatch = line2.match(/^sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)$/);
+    const lineWithoutComment = stripInlineComment(line2);
+    const sequenceMatch = lineWithoutComment.match(/^sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(\s*\([^)]*\))?\s*$/);
     if (sequenceMatch) {
       currentSequence = {
         name: sequenceMatch[1],
+        declaration: `sequence ${sequenceMatch[1]}${sequenceMatch[2] || ""}`,
         lines: []
       };
       continue;
     }
-    if (line2 === "end sequence" && currentSequence) {
+    if (lineWithoutComment === "end sequence" && currentSequence) {
       sequences.push({
         name: currentSequence.name,
+        declaration: currentSequence.declaration,
         content: currentSequence.lines.join("\n")
       });
       currentSequence = null;
@@ -108597,6 +108601,88 @@ function getVerifyTlsCertificates() {
   return verifyTlsCertificates;
 }
 
+// src/formUrlEncoded.ts
+function parseEqualsField(segment) {
+  const eqIndex = segment.indexOf("=");
+  if (eqIndex <= 0) {
+    return null;
+  }
+  return {
+    key: segment.substring(0, eqIndex).trim(),
+    value: segment.substring(eqIndex + 1).trim()
+  };
+}
+function isFormUrlEncodedContentType(contentType) {
+  return Boolean(contentType && contentType.toLowerCase().includes("application/x-www-form-urlencoded"));
+}
+function parseFormUrlEncodedLines(lines) {
+  const fields = [];
+  const errors = [];
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line2 = lines[lineIndex].trim();
+    if (!line2) {
+      continue;
+    }
+    const firstEqIndex = line2.indexOf("=");
+    const firstColonIndex = line2.indexOf(":");
+    if (firstEqIndex > 0 && (firstColonIndex === -1 || firstEqIndex < firstColonIndex)) {
+      if (line2.includes("&")) {
+        const segments = line2.split("&").map((segment) => segment.trim());
+        const hasInvalidSegment = segments.some((segment) => !parseEqualsField(segment));
+        if (hasInvalidSegment) {
+          errors.push({
+            lineIndex,
+            line: line2,
+            message: "Ampersand-delimited form body lines must use key=value for every segment."
+          });
+          continue;
+        }
+        for (const segment of segments) {
+          const field2 = parseEqualsField(segment);
+          if (field2) {
+            fields.push(field2);
+          }
+        }
+        continue;
+      }
+      const field = parseEqualsField(line2);
+      if (field) {
+        fields.push(field);
+        continue;
+      }
+    }
+    if (firstColonIndex > 0) {
+      fields.push({
+        key: line2.substring(0, firstColonIndex).trim(),
+        value: line2.substring(firstColonIndex + 1).trim()
+      });
+      continue;
+    }
+    errors.push({
+      lineIndex,
+      line: line2,
+      message: "Expected key=value, key: value, or ampersand-delimited key=value pairs."
+    });
+  }
+  return { fields, errors };
+}
+function parseFormUrlEncodedBody(body) {
+  if (!body) {
+    return { fields: [], errors: [] };
+  }
+  return parseFormUrlEncodedLines(body.split("\n"));
+}
+function encodeFormUrlEncodedBody(body) {
+  const { fields, errors } = parseFormUrlEncodedBody(body);
+  if (errors.length > 0) {
+    return { encodedBody: "", errors };
+  }
+  return {
+    encodedBody: fields.map((field) => `${encodeURIComponent(field.key)}=${encodeURIComponent(field.value)}`).join("&"),
+    errors: []
+  };
+}
+
 // src/httpClient.ts
 var sharedCookieJar = new CookieJar();
 var insecureHttpsAgent = new https2.Agent({ rejectUnauthorized: false });
@@ -108661,24 +108747,23 @@ async function sendRequestWithJar(request, jar, retryOptions) {
             (key) => key.toLowerCase() === "content-type"
           );
           const contentTypeValue = contentType ? headers[contentType] : "";
-          if (contentTypeValue.includes("application/x-www-form-urlencoded")) {
-            const lines = currentBody.split("\n").map((line2) => line2.trim()).filter((line2) => line2);
-            const params = lines.map((line2) => {
-              if (line2.includes("=")) {
-                const eqIndex = line2.indexOf("=");
-                const key = line2.substring(0, eqIndex).trim();
-                const value = line2.substring(eqIndex + 1).trim();
-                return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-              }
-              const colonIndex = line2.indexOf(":");
-              if (colonIndex > 0) {
-                const key = line2.substring(0, colonIndex).trim();
-                const value = line2.substring(colonIndex + 1).trim();
-                return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-              }
-              return encodeURIComponent(line2);
-            });
-            data = params.join("&");
+          if (isFormUrlEncodedContentType(contentTypeValue)) {
+            const encoded = encodeFormUrlEncodedBody(currentBody);
+            if (encoded.errors.length > 0) {
+              throw new NornError({
+                category: "syntax",
+                code: "invalid-form-urlencoded-body",
+                message: "Request body is not valid application/x-www-form-urlencoded syntax.",
+                details: encoded.errors.map((error) => `Body line ${error.lineIndex + 1}: ${error.message} (${error.line})`),
+                hint: "Use key=value, key: value, or a single line like key1=value1&key2=value2.",
+                context: {
+                  source: "httpClient",
+                  method: currentMethod,
+                  url: currentUrl
+                }
+              });
+            }
+            data = encoded.encodedBody;
           } else if (contentTypeValue.includes("application/json")) {
             try {
               data = JSON.parse(currentBody);
@@ -109333,6 +109418,15 @@ function buildRequestContext(parsed, context) {
     environment: context?.environment
   };
 }
+function getHeaderValueCaseInsensitive(headers, headerName) {
+  const targetName = headerName.toLowerCase();
+  for (const [name, value] of Object.entries(headers)) {
+    if (name.toLowerCase() === targetName) {
+      return value;
+    }
+  }
+  return void 0;
+}
 function describeUnresolvedLocation(label, vars) {
   if (vars.length === 0) {
     return void 0;
@@ -109388,6 +109482,20 @@ function validatePreparedRequest(parsed, context) {
       cause: error
     });
   }
+  const contentType = getHeaderValueCaseInsensitive(parsed.headers, "Content-Type");
+  if (isFormUrlEncodedContentType(contentType)) {
+    const { errors } = parseFormUrlEncodedBody(parsed.body);
+    if (errors.length > 0) {
+      throw new NornError({
+        category: "syntax",
+        code: "invalid-form-urlencoded-body",
+        message: "Request could not be prepared: invalid application/x-www-form-urlencoded body syntax.",
+        details: errors.map((error) => `Body line ${error.lineIndex + 1}: ${error.message} (${error.line})`),
+        hint: "Use key=value, key: value, or a single line like key1=value1&key2=value2.",
+        context: buildRequestContext(parsed, context)
+      });
+    }
+  }
 }
 
 // src/sequenceRunner.ts
@@ -110257,13 +110365,17 @@ function applyHeaderGroupsToRequest(parsed, requestText, headerGroups, variables
   const headerGroupNames = headerGroups.map((hg) => hg.name);
   const headerGroupHeaders = {};
   const foundGroups = [];
+  const cleanedBodyLines = [];
+  let sawRequestLine = false;
+  let inBodySection = false;
   for (const line2 of lines) {
     const trimmed = line2.trim();
     if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("var ")) {
       continue;
     }
     const methodMatch = trimmed.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
-    if (methodMatch) {
+    if (!sawRequestLine && methodMatch) {
+      sawRequestLine = true;
       const afterMethod = methodMatch[2];
       const tokens = afterMethod.split(/\s+/);
       for (let i = tokens.length - 1; i >= 0; i--) {
@@ -110275,18 +110387,22 @@ function applyHeaderGroupsToRequest(parsed, requestText, headerGroups, variables
       }
       continue;
     }
-    if (/^[A-Za-z0-9\-_]+\s*:\s*.+$/.test(trimmed)) {
+    if (!sawRequestLine) {
       continue;
     }
-    if (trimmed.startsWith("{") || trimmed.startsWith("[") || trimmed.startsWith('"')) {
-      continue;
-    }
-    const potentialGroups = trimmed.split(/\s+/);
-    for (const groupName of potentialGroups) {
-      if (headerGroupNames.includes(groupName)) {
-        foundGroups.push(groupName);
+    if (!inBodySection) {
+      if (/^[A-Za-z0-9\-_]+\s*:\s*.+$/.test(trimmed)) {
+        continue;
+      }
+      const potentialGroups = trimmed.split(/\s+/).filter(Boolean);
+      const matchingGroups = potentialGroups.filter((groupName) => headerGroupNames.includes(groupName));
+      if (matchingGroups.length > 0 && matchingGroups.length === potentialGroups.length) {
+        foundGroups.push(...matchingGroups);
+        continue;
       }
+      inBodySection = true;
     }
+    cleanedBodyLines.push(trimmed);
   }
   for (const groupName of foundGroups) {
     const group = headerGroups.find((hg) => hg.name === groupName);
@@ -110303,7 +110419,8 @@ function applyHeaderGroupsToRequest(parsed, requestText, headerGroups, variables
   modifiedUrl = modifiedUrl.trim();
   const result = {
     ...parsed,
-    url: modifiedUrl
+    url: modifiedUrl,
+    body: cleanedBodyLines.length > 0 ? substituteVariables(cleanedBodyLines.join("\n"), variables) : void 0
   };
   if (Object.keys(headerGroupHeaders).length > 0) {
     result.headers = { ...headerGroupHeaders, ...parsed.headers };
@@ -110370,13 +110487,7 @@ function resolveReturnExpression(expr, runtimeVariables) {
     return { key: varName, value: varValue };
   }
   try {
-    let current = varValue;
-    if (typeof current === "string") {
-      try {
-        current = JSON.parse(current);
-      } catch {
-      }
-    }
+    let current = parseJsonBackedValue(varValue);
     const normalizedPath = pathPart.replace(/^\.|^\[/, (m) => m === "." ? "" : "[").replace(/\[(\d+)\]/g, ".$1");
     const parts = normalizedPath.split(".").filter((p) => p !== "");
     for (const part of parts) {
@@ -110419,7 +110530,7 @@ function buildParsedNamedRequest(requestContent, runtimeVariables, apiDefinition
       const resolvedParams = {};
       for (const [paramName, paramValue] of Object.entries(apiRequest.params)) {
         if (runtimeVariables[paramValue] !== void 0) {
-          resolvedParams[paramName] = String(runtimeVariables[paramValue]);
+          resolvedParams[paramName] = valueToString2(runtimeVariables[paramValue]);
         } else {
           resolvedParams[paramName] = substituteVariables(paramValue, runtimeVariables);
         }
@@ -110726,6 +110837,16 @@ function bindSequenceArguments(params, args, runtimeVariables) {
   }
   return { variables: result };
 }
+function parseJsonBackedValue(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
 function getVariableValueByPath(path14, variables) {
   const parts = path14.split(".");
   let current = variables;
@@ -110734,9 +110855,8 @@ function getVariableValueByPath(path14, variables) {
       return "";
     }
     if (typeof current === "string") {
-      try {
-        current = JSON.parse(current);
-      } catch {
+      current = parseJsonBackedValue(current);
+      if (typeof current === "string") {
         return "";
       }
     }
@@ -110745,10 +110865,7 @@ function getVariableValueByPath(path14, variables) {
   if (current === null || current === void 0) {
     return "";
   }
-  if (typeof current === "object") {
-    return JSON.stringify(current);
-  }
-  return String(current);
+  return current;
 }
 function parseTagFilter(filterStr) {
   const match = filterStr.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(([^)]+)\))?$/);
@@ -111080,16 +111197,8 @@ function evaluateValueExpression(expr, runtimeVariables) {
   }
   const varValue = runtimeVariables[varName];
   if (pathPart) {
-    let dataToNavigate;
-    if (typeof varValue === "object" && varValue !== null) {
-      dataToNavigate = varValue;
-    } else if (typeof varValue === "string") {
-      try {
-        dataToNavigate = JSON.parse(varValue);
-      } catch {
-        return { value: varValue, error: `Cannot parse '${varName}' as JSON for path access` };
-      }
-    } else {
+    const dataToNavigate = parseJsonBackedValue(varValue);
+    if (typeof dataToNavigate !== "object" || dataToNavigate === null) {
       return { value: String(varValue), error: `Cannot access path on non-object value` };
     }
     const path14 = pathPart.replace(/^\./, "").replace(/\[(\d+)\]/g, ".$1");
@@ -111981,7 +112090,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
               duration: Date.now() - startTime
             };
           }
-          runtimeVariables[parsed.varName] = JSON.stringify(result.data);
+          runtimeVariables[parsed.varName] = result.data;
           reportProgress(stepIdx, "json", `json: ${parsed.varName} = ${parsed.filePath}`, stepResult);
           continue;
         }
@@ -112014,9 +112123,10 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
             };
           }
           let jsonObj;
-          try {
-            jsonObj = JSON.parse(runtimeVariables[parsed.varName]);
-          } catch {
+          const existingValue = parseJsonBackedValue(runtimeVariables[parsed.varName]);
+          if (typeof existingValue === "object" && existingValue !== null) {
+            jsonObj = existingValue;
+          } else {
             errors.push(`Step ${stepIdx + 1}: Variable '${parsed.varName}' is not a valid JSON object`);
             return {
               name: "",
@@ -112037,12 +112147,9 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
             const pathPart = bareVarMatch[2] || "";
             let value = runtimeVariables[varName];
             if (typeof value === "string") {
-              try {
-                const parsed2 = JSON.parse(value);
-                if (typeof parsed2 === "object" && parsed2 !== null) {
-                  value = parsed2;
-                }
-              } catch {
+              const parsedValue = parseJsonBackedValue(value);
+              if (typeof parsedValue === "object" && parsedValue !== null) {
+                value = parsedValue;
               }
             }
             if (pathPart) {
@@ -112074,7 +112181,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
               duration: Date.now() - startTime
             };
           }
-          runtimeVariables[parsed.varName] = JSON.stringify(jsonObj);
+          runtimeVariables[parsed.varName] = jsonObj;
           reportProgress(stepIdx, "propAssign", `${parsed.varName}.${parsed.propertyPath} = ${parsed.value}`, void 0);
           continue;
         }
@@ -112787,7 +112894,7 @@ ${indentMultiline(userMessage)}`;
                 body: response.body,
                 headers: response.headers
               };
-              runtimeVariables[varName] = JSON.stringify(capturedResponse);
+              runtimeVariables[varName] = capturedResponse;
               const relevantCaptures = captures.filter((c) => c.afterRequest === requestIndex);
               for (const capture of relevantCaptures) {
                 const value = getValueByPath(response, capture.path);
@@ -112921,7 +113028,7 @@ ${indentMultiline(userMessage)}`;
                   returnedObj[resolved.key] = resolved.value;
                 }
               }
-              runtimeVariables[varName] = JSON.stringify(returnedObj);
+              runtimeVariables[varName] = returnedObj;
             }
           } else {
             runtimeVariables[varName] = "";

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