norn-cli 1.2.5 → 1.3.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to the "Norn" extension will be documented in this file.
 
+## [1.3.0] - 2026-02-07
+
+### Added
+- **Retry and Backoff**: Automatically retry failed HTTP requests with configurable backoff
+  - Syntax: `GET url retry 3 backoff 200 ms` (retry up to 3 times with 200ms linear backoff)
+  - Works with direct URLs, named endpoints, and named requests
+  - Supports time units: `ms`, `s`, `seconds`, `milliseconds`
+  - Response panel shows retry indicator: 🔄 `retried 2x`
+  - CLI shows retry attempts in real-time
+  - Retries on 5xx errors, 429 rate limiting, and network failures
+
+### Improved
+- **Syntax highlighting**: Variable references `{{var}}` now highlighted inside print strings
+- **Better pattern recognition**: `test sequence` correctly terminates request blocks in all contexts
+
 ## [1.2.5] - 2026-02-07
 
 ### Improved

package/dist/cli.js

@@ -13286,6 +13286,31 @@ function stripInlineComment(line2) {
   }
   return line2;
 }
+function extractRetryOptions(line2) {
+  let cleanedLine = line2;
+  let retryCount;
+  let backoffMs;
+  const retryMatch = line2.match(/\bretry\s+(\d+)\b/i);
+  if (retryMatch) {
+    retryCount = parseInt(retryMatch[1], 10);
+    cleanedLine = cleanedLine.replace(retryMatch[0], "").trim();
+  }
+  const backoffMatch = line2.match(/\bbackoff\s+(\d+(?:\.\d+)?)\s*(s|ms|seconds?|milliseconds?)?\b/i);
+  if (backoffMatch) {
+    const value = parseFloat(backoffMatch[1]);
+    const unit = (backoffMatch[2] || "ms").toLowerCase();
+    if (unit === "s" || unit.startsWith("second")) {
+      backoffMs = value * 1e3;
+    } else {
+      backoffMs = value;
+    }
+    cleanedLine = cleanedLine.replace(backoffMatch[0], "").trim();
+  }
+  if (retryCount !== void 0 && backoffMs === void 0) {
+    backoffMs = 1e3;
+  }
+  return { cleanedLine, retryCount, backoffMs };
+}
 function extractNamedRequests(text) {
   const lines = text.split("\n");
   const namedRequests = [];
@@ -13441,7 +13466,9 @@ function parserHttpRequest(text, variables = {}) {
   if (requestLineIndex === -1) {
     throw new Error("No valid HTTP method found");
   }
-  const requestLine = stripInlineComment(allLines[requestLineIndex].trim());
+  let requestLine = stripInlineComment(allLines[requestLineIndex].trim());
+  const { cleanedLine, retryCount, backoffMs } = extractRetryOptions(requestLine);
+  requestLine = cleanedLine;
   const [method, ...urlParts] = requestLine.split(" ");
   let url2 = urlParts.join(" ");
   if (url2.startsWith('"') && url2.endsWith('"') || url2.startsWith("'") && url2.endsWith("'")) {
@@ -13490,7 +13517,7 @@ function parserHttpRequest(text, variables = {}) {
       body = void 0;
     }
   }
-  return { method: method.toUpperCase(), url: url2, headers, body };
+  return { method: method.toUpperCase(), url: url2, headers, body, retryCount, backoffMs };
 }
 function extractImports(text) {
   const lines = text.split("\n");
@@ -19463,114 +19490,157 @@ async function getAllCookies(jar) {
     secure: Boolean(c.secure)
   }));
 }
-async function sendRequest(request) {
-  return sendRequestWithJar(request, sharedCookieJar);
+async function sendRequest(request, retryOptions) {
+  return sendRequestWithJar(request, sharedCookieJar, retryOptions);
 }
-async function sendRequestWithJar(request, jar) {
-  const startTime = Date.now();
-  const maxRedirects = 10;
-  let redirectCount = 0;
-  let currentUrl = request.url;
-  let currentMethod = request.method;
-  let currentBody = request.body;
-  let finalResponse = null;
-  try {
-    while (redirectCount <= maxRedirects) {
-      const existingCookies = await jar.getCookies(currentUrl);
-      const cookieHeader = existingCookies.map((c) => `${c.key}=${c.value}`).join("; ");
-      const headers = { ...request.headers };
-      if (cookieHeader) {
-        headers["Cookie"] = cookieHeader;
-      }
-      let data = void 0;
-      if (currentBody) {
-        const contentType = Object.keys(headers).find(
-          (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)}`;
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function shouldRetry(response, error) {
+  if (error) return true;
+  if (response && (response.status >= 500 || response.status === 429)) return true;
+  return false;
+}
+async function sendRequestWithJar(request, jar, retryOptions) {
+  const totalAttempts = (retryOptions?.retryCount ?? 0) + 1;
+  const backoffMs = retryOptions?.backoffMs ?? 1e3;
+  const retriedErrors = [];
+  let lastError = null;
+  let attemptsMade = 0;
+  for (let attempt = 1; attempt <= totalAttempts; attempt++) {
+    attemptsMade = attempt;
+    const startTime = Date.now();
+    const maxRedirects = 10;
+    let redirectCount = 0;
+    let currentUrl = request.url;
+    let currentMethod = request.method;
+    let currentBody = request.body;
+    let finalResponse = null;
+    try {
+      while (redirectCount <= maxRedirects) {
+        const existingCookies = await jar.getCookies(currentUrl);
+        const cookieHeader = existingCookies.map((c) => `${c.key}=${c.value}`).join("; ");
+        const headers = { ...request.headers };
+        if (cookieHeader) {
+          headers["Cookie"] = cookieHeader;
+        }
+        let data = void 0;
+        if (currentBody) {
+          const contentType = Object.keys(headers).find(
+            (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("&");
+          } else if (contentTypeValue.includes("application/json")) {
+            try {
+              data = JSON.parse(currentBody);
+            } catch {
+              data = currentBody;
             }
-            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)}`;
+          } else {
+            try {
+              data = JSON.parse(currentBody);
+            } catch {
+              data = currentBody;
             }
-            return encodeURIComponent(line2);
-          });
-          data = params.join("&");
-        } else if (contentTypeValue.includes("application/json")) {
-          try {
-            data = JSON.parse(currentBody);
-          } catch {
-            data = currentBody;
           }
-        } else {
-          try {
-            data = JSON.parse(currentBody);
-          } catch {
-            data = currentBody;
+        }
+        const response = await axios_default({
+          method: currentMethod,
+          url: currentUrl,
+          headers,
+          data,
+          timeout: 3e4,
+          maxRedirects: 0,
+          validateStatus: () => true
+        });
+        const setCookieHeader = response.headers["set-cookie"];
+        if (setCookieHeader) {
+          const cookies2 = Array.isArray(setCookieHeader) ? setCookieHeader : [setCookieHeader];
+          for (const cookieStr of cookies2) {
+            try {
+              await jar.setCookie(cookieStr, currentUrl);
+            } catch {
+            }
           }
         }
-      }
-      const response = await axios_default({
-        method: currentMethod,
-        url: currentUrl,
-        headers,
-        data,
-        timeout: 3e4,
-        maxRedirects: 0,
-        // Disable automatic redirects
-        validateStatus: () => true
-      });
-      const setCookieHeader = response.headers["set-cookie"];
-      if (setCookieHeader) {
-        const cookies2 = Array.isArray(setCookieHeader) ? setCookieHeader : [setCookieHeader];
-        for (const cookieStr of cookies2) {
-          try {
-            await jar.setCookie(cookieStr, currentUrl);
-          } catch {
+        if (response.status >= 300 && response.status < 400 && response.headers["location"]) {
+          redirectCount++;
+          const location = response.headers["location"];
+          currentUrl = new URL(location, currentUrl).toString();
+          if (currentMethod !== "GET" && currentMethod !== "HEAD") {
+            currentMethod = "GET";
+            currentBody = void 0;
           }
+          continue;
         }
+        finalResponse = response;
+        break;
       }
-      if (response.status >= 300 && response.status < 400 && response.headers["location"]) {
-        redirectCount++;
-        const location = response.headers["location"];
-        currentUrl = new URL(location, currentUrl).toString();
-        if (currentMethod !== "GET" && currentMethod !== "HEAD") {
-          currentMethod = "GET";
-          currentBody = void 0;
+      if (!finalResponse) {
+        throw new Error("Too many redirects");
+      }
+      if (shouldRetry(finalResponse, null) && attempt < totalAttempts) {
+        const waitMs = backoffMs * attempt;
+        const errorMessage = `HTTP ${finalResponse.status} ${finalResponse.statusText}`;
+        retriedErrors.push(`Attempt ${attempt}: ${errorMessage}`);
+        if (retryOptions?.onRetry) {
+          retryOptions.onRetry(attempt, totalAttempts, errorMessage, waitMs);
         }
+        await sleep(waitMs);
         continue;
       }
-      finalResponse = response;
-      break;
-    }
-    if (!finalResponse) {
-      throw new Error("Too many redirects");
+      const cookies = await getAllCookies(jar);
+      const result = {
+        status: finalResponse.status,
+        statusText: finalResponse.statusText,
+        headers: finalResponse.headers,
+        body: finalResponse.data,
+        duration: Date.now() - startTime,
+        cookies
+      };
+      if (attemptsMade > 1 || totalAttempts > 1) {
+        result.retryInfo = {
+          attemptsMade,
+          totalAttempts,
+          retriedErrors
+        };
+      }
+      return result;
+    } catch (error) {
+      const errorMessage = error.message || String(error);
+      lastError = new Error(`${errorMessage}
+URL used: ${currentUrl || request.url}`);
+      if (attempt < totalAttempts) {
+        const waitMs = backoffMs * attempt;
+        retriedErrors.push(`Attempt ${attempt}: ${errorMessage}`);
+        if (retryOptions?.onRetry) {
+          retryOptions.onRetry(attempt, totalAttempts, errorMessage, waitMs);
+        }
+        await sleep(waitMs);
+        continue;
+      }
+      throw lastError;
     }
-    const cookies = await getAllCookies(jar);
-    return {
-      status: finalResponse.status,
-      statusText: finalResponse.statusText,
-      headers: finalResponse.headers,
-      body: finalResponse.data,
-      duration: Date.now() - startTime,
-      cookies
-    };
-  } catch (error) {
-    const originalError = error.message || String(error);
-    const urlUsed = currentUrl || request.url;
-    throw new Error(`${originalError}
-URL used: ${urlUsed}`);
   }
+  throw lastError || new Error("Request failed");
 }
 
 // src/scriptRunner.ts
@@ -19955,17 +20025,20 @@ function isRunNamedRequestCommand(line2) {
   if (/^(bash|js|powershell)\s+/i.test(afterRun)) {
     return false;
   }
-  return /^[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?$/.test(afterRun);
+  return /^[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?(?:\s+retry\s+\d+)?(?:\s+backoff\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?)?$/i.test(afterRun);
 }
 function parseRunNamedRequestCommand(line2) {
   const trimmed = line2.trim();
-  const match = trimmed.match(/^run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\(([^)]*)\))?$/i);
+  const { cleanedLine, retryCount, backoffMs } = extractRetryOptions(trimmed);
+  const match = cleanedLine.match(/^run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\(([^)]*)\))?$/i);
   if (!match) {
     return null;
   }
   return {
     name: match[1],
-    args: parseRunArguments(match[2] || "")
+    args: parseRunArguments(match[2] || ""),
+    retryCount,
+    backoffMs
   };
 }
 function isReturnStatement(line2) {
@@ -20061,7 +20134,7 @@ function parseRunArguments(argsStr) {
 }
 function isVarRunSequenceCommand(line2) {
   const trimmed = line2.trim();
-  if (!/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*run\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?\s*$/i.test(trimmed)) {
+  if (!/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*run\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?(?:\s+retry\s+\d+)?(?:\s+backoff\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?)?\s*$/i.test(trimmed)) {
     return false;
   }
   const match = trimmed.match(/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*run\s+([a-zA-Z_][a-zA-Z0-9_-]*)/i);
@@ -20075,14 +20148,17 @@ function isVarRunSequenceCommand(line2) {
 }
 function parseVarRunSequenceCommand(line2) {
   const trimmed = line2.trim();
-  const match = trimmed.match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\(([^)]*)\))?\s*$/i);
+  const { cleanedLine, retryCount, backoffMs } = extractRetryOptions(trimmed);
+  const match = cleanedLine.match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\(([^)]*)\))?\s*$/i);
   if (!match) {
     return null;
   }
   return {
     varName: match[1],
     sequenceName: match[2],
-    args: parseRunArguments(match[3] || "")
+    args: parseRunArguments(match[3] || ""),
+    retryCount,
+    backoffMs
   };
 }
 function bindSequenceArguments(params, args, runtimeVariables) {
@@ -20434,10 +20510,13 @@ function parseVarRequestCommand(line2) {
   if (!match) {
     return null;
   }
+  const { cleanedLine: url2, retryCount, backoffMs } = extractRetryOptions(match[3].trim());
   return {
     varName: match[1],
     method: match[2].toUpperCase(),
-    url: match[3].trim()
+    url: url2,
+    retryCount,
+    backoffMs
   };
 }
 function isVarAssignCommand(line2) {
@@ -20668,7 +20747,7 @@ function valueToString2(value) {
   }
   return String(value);
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function isIfCommand(line2) {
@@ -21147,7 +21226,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
     if (step.type === "wait") {
       const durationMs = parseWaitCommand(step.content);
       reportProgress(stepIdx, "wait", `wait: ${durationMs}ms`);
-      await sleep(durationMs);
+      await sleep2(durationMs);
       const stepResult = {
         type: "print",
         stepIndex: stepIdx,
@@ -21388,7 +21467,14 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           requestText += "\n" + headerLines.join("\n");
         }
         const requestParsed = parserHttpRequest(requestText, runtimeVariables);
-        const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar) : await sendRequest(requestParsed);
+        const retryOpts = parsed.retryCount ? {
+          retryCount: parsed.retryCount,
+          backoffMs: parsed.backoffMs || 1e3,
+          onRetry: (attempt, total, error, waitMs) => {
+            reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] ${requestDescription} - waiting ${waitMs}ms`, void 0);
+          }
+        } : void 0;
+        const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
         addResponse(response);
         responseIndexToVariable.set(responses.length, parsed.varName);
         runtimeVariables[parsed.varName] = response;
@@ -21641,20 +21727,29 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
       let requestUrl = "";
       let requestMethod = "";
       try {
-        const parsed2 = parserHttpRequest(namedRequest.content, runtimeVariables);
-        requestUrl = parsed2.url;
-        requestMethod = parsed2.method;
-        const response = cookieJar ? await sendRequestWithJar(parsed2, cookieJar) : await sendRequest(parsed2);
+        const requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
+        requestUrl = requestParsed.url;
+        requestMethod = requestParsed.method;
+        const effectiveRetryCount = parsed.retryCount ?? requestParsed.retryCount;
+        const effectiveBackoffMs = parsed.backoffMs ?? requestParsed.backoffMs ?? 1e3;
+        const retryOpts = effectiveRetryCount ? {
+          retryCount: effectiveRetryCount,
+          backoffMs: effectiveBackoffMs,
+          onRetry: (attempt, total, error, waitMs) => {
+            reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] run ${targetName} - waiting ${waitMs}ms`, void 0);
+          }
+        } : void 0;
+        const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
         addResponse(response);
         const stepResult = {
           type: "request",
           stepIndex: stepIdx,
           response,
-          requestMethod: parsed2.method,
-          requestUrl: parsed2.url
+          requestMethod: requestParsed.method,
+          requestUrl: requestParsed.url
         };
         orderedSteps.push(stepResult);
-        reportProgress(stepIdx, "namedRequest", `run ${targetName} \u2192 ${parsed2.method} ${parsed2.url}`, stepResult);
+        reportProgress(stepIdx, "namedRequest", `run ${targetName} \u2192 ${requestParsed.method} ${requestParsed.url}`, stepResult);
         const relevantCaptures = captures.filter((c) => c.afterRequest === requestIndex);
         for (const capture of relevantCaptures) {
           const value = getValueByPath(response, capture.path);
@@ -21732,20 +21827,29 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
         let requestUrl = "";
         let requestMethod = "";
         try {
-          const parsed2 = parserHttpRequest(namedRequest.content, runtimeVariables);
-          requestUrl = parsed2.url;
-          requestMethod = parsed2.method;
-          const response = cookieJar ? await sendRequestWithJar(parsed2, cookieJar) : await sendRequest(parsed2);
+          const requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
+          requestUrl = requestParsed.url;
+          requestMethod = requestParsed.method;
+          const effectiveRetryCount = parsed.retryCount ?? requestParsed.retryCount;
+          const effectiveBackoffMs = parsed.backoffMs ?? requestParsed.backoffMs ?? 1e3;
+          const retryOpts = effectiveRetryCount ? {
+            retryCount: effectiveRetryCount,
+            backoffMs: effectiveBackoffMs,
+            onRetry: (attempt, total, error, waitMs) => {
+              reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] var ${varName} = run ${sequenceName} - waiting ${waitMs}ms`, void 0);
+            }
+          } : void 0;
+          const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
           addResponse(response);
           const stepResult = {
             type: "request",
             stepIndex: stepIdx,
             response,
-            requestMethod: parsed2.method,
-            requestUrl: parsed2.url
+            requestMethod: requestParsed.method,
+            requestUrl: requestParsed.url
           };
           orderedSteps.push(stepResult);
-          reportProgress(stepIdx, "namedRequest", `var ${varName} = run ${sequenceName} \u2192 ${parsed2.method} ${parsed2.url}`, stepResult);
+          reportProgress(stepIdx, "namedRequest", `var ${varName} = run ${sequenceName} \u2192 ${requestParsed.method} ${requestParsed.url}`, stepResult);
           const capturedResponse = {
             status: response.status,
             statusText: response.statusText,
@@ -21951,7 +22055,15 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
           parsed = parserHttpRequest(step.content, runtimeVariables);
           requestDescription = `${parsed.method} ${parsed.url}`;
         }
-        const response = cookieJar ? await sendRequestWithJar(parsed, cookieJar) : await sendRequest(parsed);
+        const { retryCount, backoffMs } = extractRetryOptions(step.content);
+        const retryOpts = retryCount ?? parsed.retryCount ? {
+          retryCount: retryCount ?? parsed.retryCount ?? 0,
+          backoffMs: backoffMs ?? parsed.backoffMs ?? 1e3,
+          onRetry: (attempt, total, error, waitMs) => {
+            reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] ${requestDescription} - waiting ${waitMs}ms`, void 0);
+          }
+        } : void 0;
+        const response = cookieJar ? await sendRequestWithJar(parsed, cookieJar, retryOpts) : await sendRequest(parsed, retryOpts);
         addResponse(response);
         const stepResult = {
           type: "request",
@@ -22264,12 +22376,14 @@ function formatResponse(response, options) {
   const icon = isSuccess ? colors.checkmark : colors.cross;
   if (method && url2) {
     const displayUrl = redactUrl(url2, redaction);
+    const retryInfo = response.retryInfo && response.retryInfo.attemptsMade > 1 ? ` ${colors.warning(`[retried ${response.retryInfo.attemptsMade - 1}x]`)}` : "";
     lines.push(
-      `${prefix}${icon} ${colors.method(method)} ${displayUrl} ${statusColor(`(${response.status} ${response.statusText})`)} ${colors.duration(formatDuration(response.duration))}`
+      `${prefix}${icon} ${colors.method(method)} ${displayUrl} ${statusColor(`(${response.status} ${response.statusText})`)} ${colors.duration(formatDuration(response.duration))}${retryInfo}`
     );
   } else {
+    const retryInfo = response.retryInfo && response.retryInfo.attemptsMade > 1 ? ` ${colors.warning(`[retried ${response.retryInfo.attemptsMade - 1}x]`)}` : "";
     lines.push(
-      `${prefix}${statusColor(`${response.status} ${response.statusText}`)} ${colors.duration(`(${formatDuration(response.duration)})`)}`
+      `${prefix}${statusColor(`${response.status} ${response.statusText}`)} ${colors.duration(`(${formatDuration(response.duration)})`)}${retryInfo}`
     );
   }
   if (verbose || showDetails) {
@@ -22319,11 +22433,12 @@ function formatResponseCompact(response, options) {
   const statusColor = getStatusColor(colors, response.status);
   const isSuccess = response.status >= 200 && response.status < 300;
   const icon = isSuccess ? colors.checkmark : colors.cross;
+  const retryInfo = response.retryInfo && response.retryInfo.attemptsMade > 1 ? ` ${colors.warning(`[retried ${response.retryInfo.attemptsMade - 1}x]`)}` : "";
   if (method && url2) {
     const displayUrl = redactUrl(url2, redaction);
-    return `${prefix}${icon} ${colors.method(method)} ${displayUrl} ${statusColor(`${response.status}`)} ${colors.duration(formatDuration(response.duration))}`;
+    return `${prefix}${icon} ${colors.method(method)} ${displayUrl} ${statusColor(`${response.status}`)} ${colors.duration(formatDuration(response.duration))}${retryInfo}`;
   }
-  return `${prefix}${icon} ${statusColor(`${response.status} ${response.statusText}`)} ${colors.duration(formatDuration(response.duration))}`;
+  return `${prefix}${icon} ${statusColor(`${response.status} ${response.statusText}`)} ${colors.duration(formatDuration(response.duration))}${retryInfo}`;
 }
 
 // src/cli/formatters/assertion.ts

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