Merge pull request #5276 from harder/harder/issue-5275-textview-osc8

Fixes #5275. Clear stale TextView OSC 8 hyperlinks

Author: tig

Terminal.Gui/Drivers/AnsiHandling/Osc8UrlLinker.cs

@@ -3,6 +3,8 @@ namespace Terminal.Gui.Drivers;
 
 internal static class Osc8UrlLinker
 {
+    internal readonly record struct UrlRange (int Start, int Length, string Url);
+
     internal readonly struct Options
     {
         internal readonly string [] _allowedSchemes;
@@ -30,6 +32,11 @@ internal static StringBuilder WrapOsc8 (StringBuilder input)
         return WrapOsc8 (input, _defaultOptions);
     }
 
+    internal static List<UrlRange> FindUrls (string input)
+    {
+        return FindUrls (input, _defaultOptions);
+    }
+
     internal static StringBuilder WrapOsc8 (StringBuilder input, Options options)
     {
         if (input.Length == 0)
@@ -103,6 +110,76 @@ internal static StringBuilder WrapOsc8 (StringBuilder input, Options options)
         return result;
     }
 
+    private static List<UrlRange> FindUrls (string input, Options options)
+    {
+        List<UrlRange> ranges = [];
+        ReadOnlySpan<char> span = input.AsSpan ();
+        ReadOnlySpan<char> delimiter = "://".AsSpan ();
+        int i = 0;
+
+        while (i < span.Length)
+        {
+            int rel = span.Slice (i).IndexOf (delimiter, StringComparison.Ordinal);
+            if (rel < 0)
+            {
+                break;
+            }
+
+            int delimAt = i + rel;
+            int schemeEnd = delimAt;
+            int schemeStart = schemeEnd - 1;
+
+            while (schemeStart >= 0 && char.IsLetter (span [schemeStart]))
+            {
+                schemeStart--;
+            }
+
+            schemeStart++;
+
+            if (schemeStart < 0 || schemeStart >= schemeEnd)
+            {
+                i = delimAt + delimiter.Length;
+                continue;
+            }
+
+            ReadOnlySpan<char> scheme = span.Slice (schemeStart, schemeEnd - schemeStart);
+            if (!IsAllowedScheme (scheme, options))
+            {
+                i = delimAt + delimiter.Length;
+                continue;
+            }
+
+            int urlStart = schemeStart;
+            int j = delimAt + delimiter.Length;
+
+            while (j < span.Length && !IsUrlTerminator (span [j]))
+            {
+                j++;
+            }
+
+            int urlEnd = TrimTrailingPunctuation (span, urlStart, j);
+            if (urlEnd <= (delimAt + delimiter.Length))
+            {
+                i = j;
+                continue;
+            }
+
+            string candidate = span.Slice (urlStart, urlEnd - urlStart).ToString ();
+
+            Uri? _;
+            if (options._validateWithUri && !IsValidUrl (candidate, options, out _))
+            {
+                i = j;
+                continue;
+            }
+
+            ranges.Add (new (urlStart, urlEnd - urlStart, candidate));
+            i = j;
+        }
+
+        return ranges;
+    }
+
     private static int ParseEscapeSequence (string text, int start, int len)
     {
         int i = start;
@@ -341,4 +418,4 @@ private static bool IsValidUrl (string candidate, Options options, out Uri? uri)
         uri = null;
         return false;
     }
-}
+}

Terminal.Gui/Drivers/Output/OutputBase.cs

@@ -58,13 +58,27 @@ public bool IsLegacyConsole
     // Last URL used for tracking hyperlink state
     private string? _lastUrl = null;
 
+    // Rows that contained URLs in the last rendered frame; used to emit OSC 8 close
+    // before re-rendering a row that has since lost all URL cells, so terminals don't
+    // keep stale hyperlink metadata.
+    private readonly HashSet<int> _rowsWithUrls = [];
+
+    // Identifies the buffer state we last synced _rowsWithUrls against. When the buffer
+    // is replaced, resized, or its URL maps are wiped, this stops matching and we drop
+    // the stale tracking before reading it.
+    private IOutputBuffer? _lastTrackedBuffer;
+    private int _lastTrackedRows;
+    private int _lastTrackedCols;
+    private int _lastTrackedUrlVersion;
+
     private readonly StringBuilder _lastOutputStringBuilder = new ();
     private bool _clearLastOutputPending;
 
     /// <summary>
-    ///     Writes dirty cells from the buffer to the console. Hides cursor, iterates rows/cols,
-    ///     skips clean cells, batches dirty cells into ANSI sequences, wraps URLs with OSC 8,
-    ///     then renders sixel images. Cursor visibility is managed by <c>ApplicationMainLoop.SetCursor()</c>.
+    ///     Writes dirty cells from the buffer to the console. Iterates rows/cols, skips clean cells,
+    ///     batches dirty cells into ANSI sequences, emits OSC 8 hyperlink start/close around URL cells,
+    ///     and finally renders queued sixel images. Cursor visibility is managed by
+    ///     <c>ApplicationMainLoop.SetCursor()</c>.
     /// </summary>
     public virtual void Write (IOutputBuffer buffer)
     {
@@ -77,6 +91,8 @@ public virtual void Write (IOutputBuffer buffer)
         Attribute? redrawAttr = null;
         int lastCol = -1;
 
+        InvalidateRowsWithUrlsIfStale (buffer, rows, cols);
+
         // Process each row
         for (int row = top; row < rows; row++)
         {
@@ -93,9 +109,22 @@ public virtual void Write (IOutputBuffer buffer)
                 return;
             }
 
+            if (!IsLegacyConsole && buffer is OutputBufferImpl outputBuffer)
+            {
+                outputBuffer.SyncAutoUrlsForRow (row);
+            }
+
+            bool rowHadUrlsPreviously = _rowsWithUrls.Contains (row);
+            bool rowHasUrlsNow = !IsLegacyConsole && RowContainsUrls (buffer, row, cols);
+
             outputStringBuilder.Clear ();
             _lastUrl = null; // Reset URL state at the start of each row
 
+            if (!IsLegacyConsole && rowHadUrlsPreviously && !rowHasUrlsNow)
+            {
+                outputStringBuilder.Append (EscSeqUtils.OSC_EndHyperlink ());
+            }
+
             // Process columns in row
             for (int col = left; col < cols; col++)
             {
@@ -170,6 +199,21 @@ public virtual void Write (IOutputBuffer buffer)
                 }
             }
 
+            // Track row's URL status BEFORE the early-exit so _rowsWithUrls stays consistent
+            // with the buffer state — even for rows whose cells were all flushed via WriteToConsole
+            // during the inner loop (leaving outputStringBuilder empty at this point).
+            if (!IsLegacyConsole)
+            {
+                if (rowHasUrlsNow)
+                {
+                    _rowsWithUrls.Add (row);
+                }
+                else
+                {
+                    _rowsWithUrls.Remove (row);
+                }
+            }
+
             // Flush buffered output for row. Even when nothing remains buffered, an OSC 8 hyperlink
             // may still be open in the terminal because it was started in a prior batch flushed by
             // WriteToConsole and the row ended (or only clean cells followed) before any cell with
@@ -197,9 +241,7 @@ public virtual void Write (IOutputBuffer buffer)
 
             SetCursorPositionImpl (lastCol, row);
 
-            // Wrap URLs with OSC 8 hyperlink sequences
-            StringBuilder processed = Osc8UrlLinker.WrapOsc8 (outputStringBuilder);
-            Write (processed);
+            Write (outputStringBuilder);
         }
 
         if (IsLegacyConsole)
@@ -442,6 +484,11 @@ public string ToAnsi (IOutputBuffer buffer)
             return output.ToString ();
         }
 
+        if (buffer is OutputBufferImpl outputBuffer)
+        {
+            outputBuffer.SyncAutoUrlsForAllRows ();
+        }
+
         StringBuilder ansiOutput = new ();
         Attribute? lastAttr = null;
 
@@ -451,24 +498,45 @@ public string ToAnsi (IOutputBuffer buffer)
     }
 
     /// <summary>
-    ///     Writes buffered output to console, wrapping URLs with OSC 8 hyperlinks (non-legacy only),
-    ///     then clears the buffer and advances <paramref name="lastCol"/> by <paramref name="outputWidth"/>.
+    ///     Writes buffered output to console, then clears the buffer and advances
+    ///     <paramref name="lastCol"/> by <paramref name="outputWidth"/>.
     /// </summary>
     private void WriteToConsole (StringBuilder output, ref int lastCol, ref int outputWidth)
     {
-        if (IsLegacyConsole)
-        {
-            Write (output);
-        }
-        else
-        {
-            // Wrap URLs with OSC 8 hyperlink sequences
-            StringBuilder processed = Osc8UrlLinker.WrapOsc8 (output);
-            Write (processed);
-        }
+        Write (output);
 
         output.Clear ();
         lastCol += outputWidth;
         outputWidth = 0;
     }
+
+    private static bool RowContainsUrls (IOutputBuffer buffer, int row, int cols)
+    {
+        for (int col = 0; col < cols; col++)
+        {
+            if (!string.IsNullOrEmpty (buffer.GetCellUrl (col, row)))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private void InvalidateRowsWithUrlsIfStale (IOutputBuffer buffer, int rows, int cols)
+    {
+        int urlVersion = buffer is OutputBufferImpl outputBuffer ? outputBuffer.UrlStateVersion : 0;
+
+        if (!ReferenceEquals (_lastTrackedBuffer, buffer)
+            || _lastTrackedRows != rows
+            || _lastTrackedCols != cols
+            || _lastTrackedUrlVersion != urlVersion)
+        {
+            _rowsWithUrls.Clear ();
+            _lastTrackedBuffer = buffer;
+            _lastTrackedRows = rows;
+            _lastTrackedCols = cols;
+            _lastTrackedUrlVersion = urlVersion;
+        }
+    }
 }