@usebruno/js 0.46.1 → 0.48.0

package/src/utils/error-formatter.js

@@ -1,9 +1,12 @@
 const fs = require('fs');
+const path = require('path');
 const YAML = require('yaml');
 const { NODEVM_SCRIPT_WRAPPER_OFFSET, QUICKJS_SCRIPT_WRAPPER_OFFSET } = require('./sandbox');
 
+const posixifyPath = (p) => (p ? p.replace(/\\/g, '/') : p);
+
 const DEFAULT_CONTEXT_LINES = 5;
-const ALLOWED_SOURCE_EXTENSIONS = ['.bru', '.yml', '.yaml'];
+const ALLOWED_SOURCE_EXTENSIONS = ['.bru', '.yml'];
 
 const isAllowedSourceFile = (filePath) =>
   typeof filePath === 'string' && ALLOWED_SOURCE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
@@ -64,9 +67,45 @@ const findScriptBlockStartLine = (filePath, scriptType, cache = null) => {
   return result;
 };
 
+/** Find the 1-indexed last content line of a script block in a .bru file (excludes closing }) */
+const findScriptBlockEndLine = (filePath, scriptType, cache = null) => {
+  if (!filePath.endsWith('.bru')) return null;
+
+  const cacheKey = `bru-end:${filePath}:${scriptType}`;
+  if (cache?.has(cacheKey)) return cache.get(cacheKey);
+
+  const content = readFile(filePath, cache);
+  if (!content) return null;
+
+  const pattern = BLOCK_PATTERNS[scriptType];
+  if (!pattern) return null;
+
+  const lines = content.split('\n');
+  let inBlock = false;
+  let hasContent = false;
+  let result = null;
+  for (let i = 0; i < lines.length; i++) {
+    if (!inBlock && pattern.test(lines[i])) {
+      inBlock = true;
+      continue;
+    }
+    if (inBlock) {
+      if (/^\}/.test(lines[i])) {
+        // Closing brace at 0-indexed position i; last content line is at 0-indexed (i-1) = 1-indexed i
+        result = hasContent ? i : null;
+        break;
+      }
+      hasContent = true;
+    }
+  }
+
+  if (cache) cache.set(cacheKey, result);
+  return result;
+};
+
 /** Find the 1-indexed line where a script block's content starts in a .yml file */
 const findYmlScriptBlockStartLine = (filePath, scriptType, cache = null) => {
-  if (!filePath.endsWith('.yml') && !filePath.endsWith('.yaml')) return null;
+  if (!filePath.endsWith('.yml')) return null;
 
   const cacheKey = `yml:${filePath}:${scriptType}`;
   if (cache?.has(cacheKey)) return cache.get(cacheKey);
@@ -97,7 +136,52 @@ const findYmlScriptBlockStartLine = (filePath, scriptType, cache = null) => {
             }
           }
         }
-        if (result) break;
+        if (result != null) break;
+      }
+    }
+  } catch {
+    // invalid YAML
+  }
+
+  if (cache) cache.set(cacheKey, result);
+  return result;
+};
+
+/** Find the 1-indexed last content line of a script block in a .yml file */
+const findYmlScriptBlockEndLine = (filePath, scriptType, cache = null) => {
+  if (!filePath.endsWith('.yml')) return null;
+
+  const cacheKey = `yml-end:${filePath}:${scriptType}`;
+  if (cache?.has(cacheKey)) return cache.get(cacheKey);
+
+  const content = readFile(filePath, cache);
+  if (!content) return null;
+
+  const ymlType = SCRIPT_TYPE_TO_YML[scriptType];
+  if (!ymlType) return null;
+
+  let result = null;
+  try {
+    const lineCounter = new YAML.LineCounter();
+    const doc = YAML.parseDocument(content, { lineCounter });
+
+    const scriptPaths = [['runtime', 'scripts'], ['request', 'scripts']];
+    for (const scriptPath of scriptPaths) {
+      const scripts = doc.getIn(scriptPath, true);
+      if (YAML.isSeq(scripts)) {
+        for (const item of scripts.items) {
+          if (!YAML.isMap(item)) continue;
+          if (item.get('type') === ymlType) {
+            const codeNode = item.get('code', true);
+            if (codeNode && codeNode.range) {
+              // range[1] is the end offset; go back 1 to get the last content character
+              const endOffset = Math.max(codeNode.range[1] - 1, codeNode.range[0]);
+              result = lineCounter.linePos(endOffset).line;
+              break;
+            }
+          }
+        }
+        if (result != null) break;
       }
     }
   } catch {
@@ -111,7 +195,7 @@ const findYmlScriptBlockStartLine = (filePath, scriptType, cache = null) => {
 /** Adjust a runtime-reported line number to the actual line in the .bru/.yml file */
 const adjustLineNumber = (filePath, reportedLine, isQuickJS, scriptType = null, cache = null, scriptMetadata = null) => {
   const isBruFile = filePath.endsWith('.bru');
-  const isYmlFile = filePath.endsWith('.yml') || filePath.endsWith('.yaml');
+  const isYmlFile = filePath.endsWith('.yml');
 
   if (!isBruFile && !isYmlFile) {
     return reportedLine;
@@ -157,6 +241,13 @@ const adjustLineNumber = (filePath, reportedLine, isQuickJS, scriptType = null,
   return scriptRelativeLine;
 };
 
+/** Look up the script block start line for a .bru or .yml file */
+const findBlockStart = (filePath, scriptType, cache) => {
+  if (filePath.endsWith('.bru')) return findScriptBlockStartLine(filePath, scriptType, cache);
+  if (filePath.endsWith('.yml')) return findYmlScriptBlockStartLine(filePath, scriptType, cache);
+  return null;
+};
+
 /**
  * Resolve an error in a collection/folder script segment to its source file and line.
  * Uses the segments array in metadata to find which segment the error falls in,
@@ -171,19 +262,34 @@ const resolveSegmentError = (parsed, metadata, scriptType, cache) => {
 
   for (const segment of metadata.segments) {
     if (scriptRelativeLine >= segment.startLine && scriptRelativeLine <= segment.endLine) {
-      const isBru = segment.filePath.endsWith('.bru');
-      const isYml = segment.filePath.endsWith('.yml') || segment.filePath.endsWith('.yaml');
-      if (!isBru && !isYml) return null;
-
-      const blockStartLine = isBru
-        ? findScriptBlockStartLine(segment.filePath, scriptType, cache)
-        : findYmlScriptBlockStartLine(segment.filePath, scriptType, cache);
-      if (!blockStartLine) return null;
+      if (!isAllowedSourceFile(segment.filePath)) return null;
+
+      const blockStartLine = findBlockStart(segment.filePath, scriptType, cache);
+      if (!blockStartLine) {
+        // No script block on disk — only possible when user added a new script as a draft.
+        // If we have in-memory content, return it so the caller can show the code snippet.
+        if (segment.scriptContent) {
+          return {
+            line: null,
+            filePath: segment.filePath,
+            displayPath: segment.displayPath,
+            scriptContent: segment.scriptContent,
+            // segment.startLine points to the IIFE wrapper line (`await (async () => {`),
+            // so subtracting it yields a 1-based index into the user's script content.
+            lineInScript: scriptRelativeLine - segment.startLine
+          };
+        }
+        return null;
+      }
 
       return {
         line: blockStartLine + (scriptRelativeLine - segment.startLine) - 1,
         filePath: segment.filePath,
-        displayPath: segment.displayPath
+        displayPath: segment.displayPath,
+        scriptContent: segment.scriptContent || null,
+        // segment.startLine points to the IIFE wrapper line (`await (async () => {`),
+        // so subtracting it yields a 1-based index into the user's script content.
+        lineInScript: scriptRelativeLine - segment.startLine
       };
     }
   }
@@ -248,12 +354,10 @@ const parseErrorLocation = (error) => {
   return parsed;
 };
 
-/** Read source file and extract context lines around the error location */
-const getSourceContext = (filePath, errorLine, contextLines = DEFAULT_CONTEXT_LINES, cache = null) => {
-  const content = readFile(filePath, cache);
-  if (!content) return null;
+/** Build a context-lines object from an array of source lines around an error */
+const buildContextLines = (lines, errorLine, contextLines) => {
+  if (errorLine < 1 || errorLine > lines.length) return null;
 
-  const lines = content.split('\n');
   const startLine = Math.max(1, errorLine - contextLines);
   const endLine = Math.min(lines.length, errorLine + contextLines);
 
@@ -269,6 +373,19 @@ const getSourceContext = (filePath, errorLine, contextLines = DEFAULT_CONTEXT_LI
   return { lines: contextLinesArray, startLine, errorLine };
 };
 
+/** Read source file and extract context lines around the error location */
+const getSourceContext = (filePath, errorLine, contextLines = DEFAULT_CONTEXT_LINES, cache = null) => {
+  const content = readFile(filePath, cache);
+  if (!content) return null;
+  return buildContextLines(content.split('\n'), errorLine, contextLines);
+};
+
+/** Extract context lines from in-memory script content (e.g. unsaved draft scripts) */
+const getSourceContextFromContent = (content, errorLine, contextLines = DEFAULT_CONTEXT_LINES) => {
+  if (!content) return null;
+  return buildContextLines(content.split('\n'), errorLine, contextLines);
+};
+
 /** Build adjusted stack trace string from structured CallSite data */
 const buildStackFromCallSites = (callSites, scriptType = null, cache = null, scriptMetadata = null) => {
   return callSites.map((site) => {
@@ -280,7 +397,7 @@ const buildStackFromCallSites = (callSites, scriptType = null, cache = null, scr
     if (adjusted === null && scriptMetadata?.segments) {
       const parsed = { line: site.line, isQuickJS: false };
       const resolved = resolveSegmentError(parsed, scriptMetadata, scriptType, cache);
-      if (resolved) {
+      if (resolved && resolved.line !== null) {
         fileToUse = resolved.filePath;
         lineToUse = resolved.line;
       }
@@ -307,7 +424,7 @@ const adjustStackTrace = (stack, scriptType = null, cache = null, scriptMetadata
     if (adjusted === null && scriptMetadata?.segments) {
       const parsed = { line: match.line, isQuickJS };
       const resolved = resolveSegmentError(parsed, scriptMetadata, scriptType, cache);
-      if (resolved) {
+      if (resolved && resolved.line !== null) {
         const suffix = match.isQuickJS ? ')' : '';
         return match.column !== null
           ? line.replace(`${match.filePath}:${match.line}:${match.column}${suffix}`, `${resolved.filePath}:${resolved.line}:${match.column}${suffix}`)
@@ -409,6 +526,210 @@ const formatErrorWithContext = (error, relativeFilePath = null, scriptType = nul
   return lines.join('\n');
 };
 
+/**
+ * Build a structured error context object for the desktop UI's ScriptError component.
+ *
+ * formatErrorWithContext (V1) returns a pre-formatted string for CLI output.
+ * This function returns a structured object so the desktop UI can render it
+ * with its own layout (CodeSnippet component, collapsible stack, etc.).
+ *
+ * Key difference: line numbers in the returned object are block-relative
+ * (i.e. relative to the script block, starting at 1) rather than absolute
+ * file line numbers, because users edit scripts in a CodeMirror editor that
+ * starts numbering at line 1.
+ *
+ * @example
+ * Given a .bru file at /home/user/my-collection/requests/get-user.bru:
+ *
+ *   meta {                          ← file line 1
+ *     name: get-user                ← file line 2
+ *   }                               ← file line 3
+ *                                   ← file line 4
+ *   script:post-response {          ← file line 5
+ *     const data = res.body;        ← file line 6  (script line 1)
+ *     data.missing.prop;            ← file line 7  (script line 2) ← error
+ *     console.log(data);            ← file line 8  (script line 3)
+ *   }                               ← file line 9
+ *
+ * formatErrorWithContextV2(error, 'post-response', null, '/home/user/my-collection')
+ * → {
+ *     errorType: 'TypeError',
+ *     filePath: 'requests/get-user.bru',   ← relative to collectionPath
+ *     errorLine: 2,                        ← block-relative, not file line 7
+ *     lines: [
+ *       { lineNumber: 1, content: '  const data = res.body;', isError: false },
+ *       { lineNumber: 2, content: '  data.missing.prop;',     isError: true  },
+ *       { lineNumber: 3, content: '  console.log(data);',     isError: false }
+ *     ],
+ *     stack: '    at …/requests/get-user.bru:7:3'
+ *   }
+ *
+ * V1 (formatErrorWithContext) returns a flat string for the same error:
+ *   File: requests/get-user.bru
+ *
+ *    5 |  const data = res.body;
+ *  > 6 |  data.missing.prop;
+ *    7 |  console.log(data);
+ *
+ *   TypeError: Cannot read properties of undefined
+ *       at …/requests/get-user.bru:7:3
+ *
+ * @param {Error} error - The error to build context for
+ * @param {string} scriptType - 'pre-request' | 'post-response' | 'test'
+ * @param {object} scriptMetadata - Optional metadata for line mapping in combined scripts
+ * @param {string} collectionPath - Absolute path to the collection root (used to compute relative display paths)
+ * @returns {object|null} Structured error context or null
+ */
+/**
+ * Resolve error context, preferring in-memory draft content over disk.
+ *
+ * Three resolution paths (tried in order):
+ * 1. Request-level error with in-memory draft content
+ * 2. Segment (collection/folder) error with in-memory draft content
+ * 3. Disk-based file read (original behavior)
+ *
+ * @returns {{ context, fromMemory, draftOnlyBlock }|null}
+ */
+const resolveErrorContext = ({ adjustedLine, scriptRelativeLine, metadata, segmentResult, filePath, sourceFile, sourceLine, scriptType, cache }) => {
+  // Request-level error with in-memory draft content
+  if (adjustedLine !== null && metadata?.requestScriptContent) {
+    // Check whether the script block exists on disk. When the user added a brand-new
+    // script that hasn't been saved yet, findBlockStart returns null and adjustLineNumber
+    // returned scriptRelativeLine (not a real .bru file line), so stack frame adjustment
+    // would produce misleading results — flag it as draft-only.
+    const blockStartLine = findBlockStart(filePath, scriptType, cache);
+    const draftOnlyBlock = !blockStartLine && isAllowedSourceFile(filePath);
+    // requestStartLine points to the IIFE wrapper line (`await (async () => {`),
+    // so subtracting it yields a 1-based index into the user's script content.
+    const lineInScript = scriptRelativeLine - metadata.requestStartLine;
+    const context = getSourceContextFromContent(metadata.requestScriptContent, lineInScript, 3);
+    if (context) return { context, fromMemory: true, draftOnlyBlock };
+  }
+
+  // Segment (collection/folder) error with in-memory draft content
+  if (adjustedLine === null && segmentResult?.scriptContent) {
+    const context = getSourceContextFromContent(segmentResult.scriptContent, segmentResult.lineInScript, 3);
+    // segmentResult.line is null when the block doesn't exist on disk
+    if (context) return { context, fromMemory: true, draftOnlyBlock: segmentResult.line === null };
+  }
+
+  // Fall back to reading from disk
+  if (sourceLine !== null) {
+    const context = getSourceContext(sourceFile, sourceLine, 3, cache);
+    if (context) return { context, fromMemory: false, draftOnlyBlock: false };
+  }
+
+  return null;
+};
+
+const formatErrorWithContextV2 = (error, scriptType, scriptMetadata, collectionPath) => {
+  if (!error) return null;
+
+  try {
+    const cache = new Map();
+    const metadata = (error.scriptMetadata && Object.keys(error.scriptMetadata).length > 0)
+      ? error.scriptMetadata
+      : scriptMetadata;
+    const parsed = parseErrorLocation(error);
+    if (!parsed) return null;
+
+    const { filePath } = parsed;
+    const wrapperOffset = parsed.isQuickJS ? QUICKJS_SCRIPT_WRAPPER_OFFSET : NODEVM_SCRIPT_WRAPPER_OFFSET;
+    const scriptRelativeLine = parsed.line - wrapperOffset;
+    const adjustedLine = adjustLineNumber(filePath, parsed.line, parsed.isQuickJS, scriptType, cache, metadata);
+
+    let sourceFile = filePath;
+    let sourceLine = adjustedLine;
+
+    // Handle collection/folder script segments
+    let segmentResult = null;
+    if (adjustedLine === null) {
+      segmentResult = resolveSegmentError(parsed, metadata, scriptType, cache);
+      if (!segmentResult) return null;
+      sourceFile = segmentResult.filePath;
+      sourceLine = segmentResult.line;
+    }
+
+    // Resolve context: prefer in-memory draft content, fall back to disk
+    const resolved = resolveErrorContext({
+      adjustedLine, scriptRelativeLine, metadata, segmentResult,
+      filePath, sourceFile, sourceLine, scriptType, cache
+    });
+    if (!resolved || resolved.context.lines.length === 0) return null;
+
+    const { context, fromMemory, draftOnlyBlock } = resolved;
+
+    const resolvedDisplayPath = posixifyPath(
+      collectionPath ? path.relative(collectionPath, sourceFile) : sourceFile
+    );
+
+    const errorType = getErrorTypeName(error);
+    let stack = null;
+    if (error.stack) {
+      // When the script block only exists as a draft (not on disk), adjustLineNumber
+      // cannot map to real .bru file lines — skip adjustment to preserve original frames.
+      const rawStack = draftOnlyBlock
+        ? error.stack
+        : adjustStackTrace(error.stack, scriptType, cache, metadata, parsed.isQuickJS);
+      const stackLines = rawStack.split('\n').slice(1).filter((l) => l.trim().startsWith('at'));
+      stack = stackLines.length ? stackLines.map((l) => `    ${l.trim()}`).join('\n') : null;
+    }
+
+    // When context came from in-memory content, lines are already block-relative
+    if (fromMemory) {
+      return {
+        errorType,
+        filePath: resolvedDisplayPath,
+        errorLine: context.errorLine,
+        lines: context.lines,
+        stack
+      };
+    }
+
+    // Compute block-relative line numbers for the desktop UI.
+    // Users edit scripts in a CodeMirror editor starting at line 1,
+    // so show lines relative to the script block, not absolute .bru file lines.
+    const blockStartLine = findBlockStart(sourceFile, scriptType, cache);
+
+    const isBru = sourceFile.endsWith('.bru');
+    const isYml = sourceFile.endsWith('.yml');
+    const blockEndLine = isBru
+      ? findScriptBlockEndLine(sourceFile, scriptType, cache)
+      : isYml
+        ? findYmlScriptBlockEndLine(sourceFile, scriptType, cache)
+        : null;
+
+    // If this is a .bru/.yml file but the script block is missing or empty, there's nothing to show
+    if ((isBru || isYml) && !blockEndLine) return null;
+
+    const blockOffset = blockStartLine ? blockStartLine - 1 : 0;
+
+    const filteredLines = context.lines
+      .filter((l) => {
+        const rel = l.lineNumber - blockOffset;
+        return rel >= 1 && (!blockEndLine || l.lineNumber <= blockEndLine);
+      })
+      .map((l) => ({
+        lineNumber: l.lineNumber - blockOffset,
+        content: l.content,
+        isError: l.isError
+      }));
+
+    if (filteredLines.length === 0) return null;
+
+    return {
+      errorType,
+      filePath: resolvedDisplayPath,
+      errorLine: sourceLine - blockOffset,
+      lines: filteredLines,
+      stack
+    };
+  } catch (e) {
+    console.warn('formatErrorWithContextV2 failed:', e);
+    return null;
+  }
+};
+
 module.exports = {
   SCRIPT_TYPES,
   DEFAULT_CONTEXT_LINES,
@@ -416,11 +737,15 @@ module.exports = {
   parseErrorLocation,
   buildStackFromCallSites,
   getSourceContext,
+  getSourceContextFromContent,
   formatErrorWithContext,
+  formatErrorWithContextV2,
   adjustLineNumber,
   resolveSegmentError,
   findScriptBlockStartLine,
+  findScriptBlockEndLine,
   findYmlScriptBlockStartLine,
+  findYmlScriptBlockEndLine,
   adjustStackTrace,
   getErrorTypeName
 };