feat(logViewer): correctness, performance, and UX improvements

src/i18n/en.i18n.json

@@ -79,6 +79,12 @@
       "yes": "Yes",
       "cancel": "Cancel"
     },
+    "saveLogFile": {
+      "title": "Save Log File",
+      "zipFiles": "ZIP Files",
+      "logFiles": "Log Files",
+      "allFiles": "All Files"
+    },
     "screenshare": {
       "title": "Share Your Screen",
       "announcement": "Select a screen to share"
@@ -113,6 +119,11 @@
       "message": "We will notify you when the next update is available\nIf you change your mind you can check for updates from the About menu.",
       "ok": "OK"
     },
+    "selectLogFile": {
+      "title": "Select Log File",
+      "logFiles": "Log Files",
+      "allFiles": "All Files"
+    },
     "selectClientCertificate": {
       "announcement": "Select Certificate",
       "select": "Select",
@@ -726,6 +737,7 @@
       "entries_one": "{{count}} entry",
       "entries_other": "{{count}} entries",
       "entriesOfTotal": "{{count}} of {{total}} entries",
+      "matches": "{{count}} matches",
       "noEntries": "No entries"
     },
     "buttons": {
@@ -738,6 +750,7 @@
       "copied": "Copied",
       "save": "Save",
       "saved": "Saved",
+      "showInFolder": "Show in Folder",
       "retry": "Retry",
       "dismissError": "Dismiss error",
       "clear": "Clear all",
@@ -792,6 +805,7 @@
     },
     "messages": {
       "noLogsFound": "No logs found",
+      "newEntriesPaused": "{{count}} new entries — click to resume",
       "adjustFilters": "Try adjusting your filters or refresh the logs",
       "loadFailed": "Failed to load logs",
       "saveFailed": "Failed to save logs"

src/ipc/channels.ts

@@ -123,6 +123,10 @@ type ChannelToArgsMap = {
     lastModifiedTime?: number;
     error?: string;
   };
+  'log-viewer-window/reveal-log-file': (options?: { filePath?: string }) => {
+    success: boolean;
+    error?: string;
+  };
   'log-viewer-window/confirm-clear-logs': () => boolean;
   'log-viewer-window/clear-logs': () => { success: boolean; error?: string };
   'log-viewer-window/save-logs': (options: {

src/logViewerWindow/LogViewerToolbar.tsx

@@ -13,6 +13,7 @@ export type LogViewerToolbarProps = {
   isStreaming: boolean;
   onOpenLogFile: () => void;
   onOpenDefaultLog: () => void;
+  onRevealLogFile: () => void;
   onRefresh: () => void;
   onToggleStreaming: () => void;
   onCopy: () => void;
@@ -28,6 +29,7 @@ export const LogViewerToolbar = ({
   isStreaming,
   onOpenLogFile,
   onOpenDefaultLog,
+  onRevealLogFile,
   onRefresh,
   onToggleStreaming,
   onCopy,
@@ -48,6 +50,13 @@ export const LogViewerToolbar = ({
             aria-label={t('logViewer.buttons.openLogFile')}
             onClick={onOpenLogFile}
           />
+          <IconButton
+            small
+            icon='file'
+            title={t('logViewer.buttons.showInFolder')}
+            aria-label={t('logViewer.buttons.showInFolder')}
+            onClick={onRevealLogFile}
+          />
           {!isDefaultLog && (
             <IconButton
               small

src/logViewerWindow/__tests__/LogEntry.spec.tsx

@@ -28,6 +28,8 @@ const baseEntry = (overrides: Partial<LogEntryType> = {}): LogEntryType => ({
   contextTags: ['main', 'open.rocket.chat'],
   context: 'main open.rocket.chat',
   raw: 'raw line',
+  searchText: 'hello world main open.rocket.chat',
+  rawLower: 'raw line',
   ...overrides,
 });
 

src/logViewerWindow/__tests__/LogTimeline.spec.tsx

@@ -24,6 +24,8 @@ const makeEntry = (offsetMs: number): LogEntryType => ({
   context: '',
   message: 'message',
   raw: 'raw',
+  searchText: 'message ',
+  rawLower: 'raw',
 });
 
 const entries: LogEntryType[] = Array.from({ length: 20 }, (_unused, index) =>

src/logViewerWindow/__tests__/ipc.spec.ts

@@ -0,0 +1,115 @@
+import {
+  countLogEntries,
+  getLastNEntries,
+  trimBufferToLastNewline,
+} from '../ipc';
+
+describe('trimBufferToLastNewline', () => {
+  it('returns nothing consumed when the buffer has no newline', () => {
+    const buf = Buffer.from('partial line without newline');
+    const { consumed, bytesConsumed } = trimBufferToLastNewline(buf);
+    expect(bytesConsumed).toBe(0);
+    expect(consumed.length).toBe(0);
+  });
+
+  it('consumes up to and including the last newline mid-buffer', () => {
+    const buf = Buffer.from('line one\nline two\npartial line three');
+    const { consumed, bytesConsumed } = trimBufferToLastNewline(buf);
+
+    expect(consumed.toString('utf-8')).toBe('line one\nline two\n');
+    expect(bytesConsumed).toBe(Buffer.byteLength('line one\nline two\n'));
+    expect(buf.subarray(bytesConsumed).toString('utf-8')).toBe(
+      'partial line three'
+    );
+  });
+
+  it('consumes the entire buffer when it ends with a newline', () => {
+    const buf = Buffer.from('line one\nline two\n');
+    const { consumed, bytesConsumed } = trimBufferToLastNewline(buf);
+
+    expect(bytesConsumed).toBe(buf.length);
+    expect(consumed.equals(buf)).toBe(true);
+  });
+
+  it('does not split a multi-byte UTF-8 character across the cut point', () => {
+    // "café" ends with a 2-byte UTF-8 char (é = 0xC3 0xA9); make sure the
+    // cut happens strictly after a newline, never inside a multi-byte char.
+    const completeLine = 'café logged\n';
+    const partialMultiByteTail = 'café'; // "café" without trailing newline
+    const buf = Buffer.concat([
+      Buffer.from(completeLine, 'utf-8'),
+      Buffer.from(partialMultiByteTail, 'utf-8'),
+    ]);
+
+    const { consumed, bytesConsumed } = trimBufferToLastNewline(buf);
+
+    expect(bytesConsumed).toBe(Buffer.byteLength(completeLine, 'utf-8'));
+    expect(consumed.toString('utf-8')).toBe(completeLine);
+
+    const remainder = buf.subarray(bytesConsumed);
+    expect(remainder.toString('utf-8')).toBe(partialMultiByteTail);
+  });
+
+  it('returns an empty consumed buffer for an empty input', () => {
+    const { consumed, bytesConsumed } = trimBufferToLastNewline(
+      Buffer.alloc(0)
+    );
+    expect(bytesConsumed).toBe(0);
+    expect(consumed.length).toBe(0);
+  });
+});
+
+describe('getLastNEntries', () => {
+  const buildLog = (count: number): string =>
+    Array.from(
+      { length: count },
+      (_, i) =>
+        `[2024-01-01 10:00:${String(i).padStart(2, '0')}.000] [info] [main] Entry ${i}`
+    ).join('\n');
+
+  it('returns all content and correct total when limit exceeds entry count', () => {
+    const log = buildLog(3);
+    const { content, totalEntries } = getLastNEntries(log, 10);
+    expect(totalEntries).toBe(3);
+    expect(content).toBe(log);
+  });
+
+  it('returns only the last N entries', () => {
+    const log = buildLog(5);
+    const { content, totalEntries } = getLastNEntries(log, 2);
+    expect(totalEntries).toBe(5);
+    expect(content.split('\n')).toHaveLength(2);
+    expect(content).toContain('Entry 3');
+    expect(content).toContain('Entry 4');
+    expect(content).not.toContain('Entry 2');
+  });
+
+  it('returns empty content and zero entries for a non-positive limit', () => {
+    const { content, totalEntries } = getLastNEntries(buildLog(3), 0);
+    expect(content).toBe('');
+    expect(totalEntries).toBe(0);
+  });
+
+  it('falls back to the last N lines when no entries match the log pattern', () => {
+    const content = 'plain line 1\nplain line 2\nplain line 3';
+    const result = getLastNEntries(content, 2);
+    expect(result.totalEntries).toBe(0);
+    expect(result.content).toBe('plain line 2\nplain line 3');
+  });
+});
+
+describe('countLogEntries', () => {
+  it('counts entry-start lines and ignores continuation lines', () => {
+    const content = [
+      '[2024-01-01 10:00:00.000] [info] [main] First',
+      '    continuation line',
+      '[2024-01-01 10:00:01.000] [warn] [main] Second',
+    ].join('\n');
+
+    expect(countLogEntries(content)).toBe(2);
+  });
+
+  it('returns 0 for content with no matching entries', () => {
+    expect(countLogEntries('just some text\nanother line')).toBe(0);
+  });
+});

src/logViewerWindow/__tests__/parseLogs.spec.ts

@@ -86,6 +86,30 @@ describe('parseLogLines', () => {
 
     expect(entry.level).toBe('info');
   });
+
+  it('precomputes searchText and rawLower', () => {
+    const [entry] = parseLogLines(
+      '[2026-08-07 10:00:00.000] [info] [Main] [Server-1] HELLO World'
+    );
+
+    expect(entry.searchText).toBe(
+      `${entry.message} ${entry.context}`.toLowerCase()
+    );
+    expect(entry.rawLower).toBe(entry.raw.toLowerCase());
+    expect(entry.contextTags).toEqual(['Main', 'Server-1']);
+  });
+
+  it('updates searchText when continuation lines are folded in', () => {
+    const [entry] = parseLogLines(
+      [
+        '[2026-08-07 10:00:00.000] [error] [main] Boom',
+        '    at foo (foo.js:1:1)',
+      ].join('\n')
+    );
+
+    expect(entry.searchText).toContain('at foo');
+    expect(entry.rawLower).toContain('at foo');
+  });
 });
 
 describe('timestamp helpers', () => {

src/logViewerWindow/__tests__/textHighlight.spec.ts

@@ -0,0 +1,83 @@
+import {
+  MAX_COLLAPSED_MESSAGE_LINES,
+  splitMessageForCollapse,
+  splitTextForHighlight,
+} from '../textHighlight';
+
+describe('splitTextForHighlight', () => {
+  it('returns a single unmatched segment when query is empty', () => {
+    expect(splitTextForHighlight('hello world', '')).toEqual([
+      { text: 'hello world', matched: false },
+    ]);
+  });
+
+  it('returns a single unmatched segment when there is no match', () => {
+    expect(splitTextForHighlight('hello world', 'xyz')).toEqual([
+      { text: 'hello world', matched: false },
+    ]);
+  });
+
+  it('splits and marks a single case-insensitive match', () => {
+    const result = splitTextForHighlight('Hello World', 'world');
+    expect(result).toEqual([
+      { text: 'Hello ', matched: false },
+      { text: 'World', matched: true },
+    ]);
+  });
+
+  it('marks all occurrences of the query', () => {
+    const result = splitTextForHighlight('foo bar foo', 'foo');
+    expect(result).toEqual([
+      { text: 'foo', matched: true },
+      { text: ' bar ', matched: false },
+      { text: 'foo', matched: true },
+    ]);
+  });
+
+  it('escapes regex special characters in the query', () => {
+    const result = splitTextForHighlight('a.b*c', '.b*');
+    expect(result).toEqual([
+      { text: 'a', matched: false },
+      { text: '.b*', matched: true },
+      { text: 'c', matched: false },
+    ]);
+  });
+});
+
+describe('splitMessageForCollapse', () => {
+  it('returns all lines with zero hidden count when under the threshold', () => {
+    const message = Array.from({ length: 3 }, (_, i) => `line ${i}`).join('\n');
+    const { visibleLines, hiddenLineCount } = splitMessageForCollapse(message);
+    expect(visibleLines).toHaveLength(3);
+    expect(hiddenLineCount).toBe(0);
+  });
+
+  it('returns exactly the threshold with zero hidden count at the boundary', () => {
+    const message = Array.from(
+      { length: MAX_COLLAPSED_MESSAGE_LINES },
+      (_, i) => `line ${i}`
+    ).join('\n');
+    const { visibleLines, hiddenLineCount } = splitMessageForCollapse(message);
+    expect(visibleLines).toHaveLength(MAX_COLLAPSED_MESSAGE_LINES);
+    expect(hiddenLineCount).toBe(0);
+  });
+
+  it('truncates to the threshold and reports the hidden count when over it', () => {
+    const totalLines = MAX_COLLAPSED_MESSAGE_LINES + 4;
+    const message = Array.from(
+      { length: totalLines },
+      (_, i) => `line ${i}`
+    ).join('\n');
+    const { visibleLines, hiddenLineCount } = splitMessageForCollapse(message);
+    expect(visibleLines).toHaveLength(MAX_COLLAPSED_MESSAGE_LINES);
+    expect(visibleLines).toEqual([
+      'line 0',
+      'line 1',
+      'line 2',
+      'line 3',
+      'line 4',
+      'line 5',
+    ]);
+    expect(hiddenLineCount).toBe(4);
+  });
+});

src/logViewerWindow/__tests__/timeline.spec.ts

@@ -14,6 +14,8 @@ const entry = (timestamp: string, level: LogLevel = 'info'): LogEntryType => ({
   context: 'main',
   message: 'message',
   raw: `[${timestamp}] [${level}] [main] message`,
+  searchText: 'message main',
+  rawLower: `[${timestamp}] [${level}] [main] message`.toLowerCase(),
 });
 
 describe('buildTimeline', () => {

src/logViewerWindow/__tests__/types.spec.ts

@@ -1,4 +1,4 @@
-import { isLogLevel, parseLogLevel } from '../types';
+import { isAtLeastLevel, isLogLevel, parseLogLevel } from '../types';
 
 describe('logViewerWindow types', () => {
   it('recognizes valid log levels', () => {
@@ -20,3 +20,30 @@ describe('logViewerWindow types', () => {
     expect(parseLogLevel(42)).toBe('info');
   });
 });
+
+describe('isAtLeastLevel', () => {
+  it('orders levels silly < verbose < debug < info < warn < error', () => {
+    expect(isAtLeastLevel('silly', 'silly')).toBe(true);
+    expect(isAtLeastLevel('verbose', 'silly')).toBe(true);
+    expect(isAtLeastLevel('debug', 'verbose')).toBe(true);
+    expect(isAtLeastLevel('info', 'debug')).toBe(true);
+    expect(isAtLeastLevel('warn', 'info')).toBe(true);
+    expect(isAtLeastLevel('error', 'warn')).toBe(true);
+  });
+
+  it('returns false when level is below the minimum', () => {
+    expect(isAtLeastLevel('silly', 'error')).toBe(false);
+    expect(isAtLeastLevel('debug', 'warn')).toBe(false);
+    expect(isAtLeastLevel('info', 'error')).toBe(false);
+  });
+
+  it('returns true when level equals the minimum', () => {
+    expect(isAtLeastLevel('warn', 'warn')).toBe(true);
+    expect(isAtLeastLevel('error', 'error')).toBe(true);
+  });
+
+  it('treats error as the highest severity, matching only itself and above', () => {
+    expect(isAtLeastLevel('error', 'error')).toBe(true);
+    expect(isAtLeastLevel('warn', 'error')).toBe(false);
+  });
+});

src/logViewerWindow/constants.ts

@@ -33,3 +33,6 @@ export const PAGE_SIZE = 100;
 /** Time slices drawn in the distribution timeline, and the plot's height */
 export const TIMELINE_BUCKET_COUNT = 96;
 export const TIMELINE_PLOT_HEIGHT = 40;
+
+/** Window during which scroll events are ignored after a programmatic scroll */
+export const AUTO_SCROLL_GUARD_MS = 150;