teemux 1.0.0

package/src/utils/highlightJson.ts

@@ -0,0 +1,118 @@
+import { stripHtmlTags } from './stripHtmlTags.js';
+import { unescapeHtml } from './unescapeHtml.js';
+
+/**
+ * Apply syntax highlighting to JSON text that uses HTML-escaped quotes (").
+ * Uses placeholder technique to avoid double-wrapping strings.
+ */
+export const highlightJsonText = (text: string): string => {
+  // First, extract and mark all JSON strings with placeholders
+  const strings: string[] = [];
+  let result = text.replaceAll(
+    /"((?:(?!").)*)"/gu,
+    (_match, content) => {
+      strings.push(content as string);
+      return `\u0000STR${strings.length - 1}\u0000`;
+    },
+  );
+
+  // Booleans and null
+  result = result.replaceAll(
+    /\b(true|false|null)\b/gu,
+    '<span class="json-bool">$1</span>',
+  );
+
+  // Numbers
+  result = result.replaceAll(
+    /(?<!\w)(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/gu,
+    '<span class="json-number">$1</span>',
+  );
+
+  // Restore strings with appropriate highlighting
+  result = result.replaceAll(
+    /\0STR(\d+)\0(\s*:)?/gu,
+    (_match, index, colon) => {
+      const content = strings[Number.parseInt(index as string, 10)];
+      if (colon) {
+        // This is a key
+        return `<span class="json-key">&quot;${content}&quot;</span>${colon}`;
+      }
+
+      // This is a value
+      return `<span class="json-string">&quot;${content}&quot;</span>`;
+    },
+  );
+
+  return result;
+};
+
+/**
+ * Process HTML text, applying JSON highlighting only to text outside of HTML tags.
+ */
+export const syntaxHighlightJson = (html: string): string => {
+  let result = '';
+  let index = 0;
+
+  while (index < html.length) {
+    if (html[index] === '<') {
+      // Find end of tag
+      const tagEnd = html.indexOf('>', index);
+      if (tagEnd === -1) {
+        result += html.slice(index);
+        break;
+      }
+      result += html.slice(index, tagEnd + 1);
+      index = tagEnd + 1;
+    } else {
+      // Find next tag or end of string
+      const nextTag = html.indexOf('<', index);
+      const textEnd = nextTag === -1 ? html.length : nextTag;
+      const text = html.slice(index, textEnd);
+
+      // Highlight JSON syntax in this text segment
+      result += highlightJsonText(text);
+      index = textEnd;
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Detect if the content (after prefix) is valid JSON and apply syntax highlighting.
+ * Returns the original HTML if not valid JSON.
+ */
+export const highlightJson = (html: string): string => {
+  // Extract the text content (strip HTML tags) to check if it's JSON
+  const textContent = stripHtmlTags(html);
+
+  // Unescape HTML entities for JSON parsing
+  const unescaped = unescapeHtml(textContent);
+
+  // Find where the actual log content starts (after the prefix like [name])
+  const prefixMatch = /^(\[[\w-]+\]\s*)/u.exec(unescaped);
+  const prefix = prefixMatch?.[0] ?? '';
+  const content = unescaped.slice(prefix.length).trim();
+
+  // Check if the content is valid JSON
+  if (!content.startsWith('{') && !content.startsWith('[')) {
+    return html;
+  }
+
+  try {
+    JSON.parse(content);
+  } catch {
+    return html;
+  }
+
+  // It's valid JSON - now highlight it
+  // Find the position after the prefix span in the HTML
+  const prefixHtmlMatch = /^(<span[^>]*>\[[^\]]+\]<\/span>\s*)/u.exec(html);
+  const htmlPrefix = prefixHtmlMatch?.[0] ?? '';
+  const jsonHtml = html.slice(htmlPrefix.length);
+
+  // Apply syntax highlighting to the JSON portion
+  const highlighted = syntaxHighlightJson(jsonHtml);
+
+  return htmlPrefix + highlighted;
+};

package/src/utils/linkifyUrls.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it } from 'vitest';
+import { linkifyUrls } from './linkifyUrls.js';
+
+describe('linkifyUrls', () => {
+  it('converts http URLs to links', () => {
+    const input = 'Visit http://example.com for more';
+    const result = linkifyUrls(input);
+
+    expect(result).toBe(
+      'Visit <a href="http://example.com" target="_blank" rel="noopener">http://example.com</a> for more',
+    );
+  });
+
+  it('converts https URLs to links', () => {
+    const input = 'Secure: https://example.com/path';
+    const result = linkifyUrls(input);
+
+    expect(result).toBe(
+      'Secure: <a href="https://example.com/path" target="_blank" rel="noopener">https://example.com/path</a>',
+    );
+  });
+
+  it('converts file:// URLs to links', () => {
+    const input = 'Open file:///Users/test/file.txt';
+    const result = linkifyUrls(input);
+
+    expect(result).toBe(
+      'Open <a href="file:///Users/test/file.txt" target="_blank" rel="noopener">file:///Users/test/file.txt</a>',
+    );
+  });
+
+  it('handles URLs with query parameters', () => {
+    const input = 'Link: https://example.com/search?q=test';
+    const result = linkifyUrls(input);
+
+    expect(result).toContain('href="https://example.com/search?q=test"');
+  });
+
+  it('handles URLs with port numbers', () => {
+    const input = 'Server at http://localhost:3000/api';
+    const result = linkifyUrls(input);
+
+    expect(result).toContain('href="http://localhost:3000/api"');
+  });
+
+  it('strips trailing periods', () => {
+    const input = 'Visit http://example.com.';
+    const result = linkifyUrls(input);
+
+    expect(result).toBe(
+      'Visit <a href="http://example.com" target="_blank" rel="noopener">http://example.com</a>.',
+    );
+  });
+
+  it('strips trailing commas', () => {
+    const input = 'URLs: http://a.com, http://b.com';
+    const result = linkifyUrls(input);
+
+    expect(result).toContain(
+      '<a href="http://a.com" target="_blank" rel="noopener">http://a.com</a>,',
+    );
+    expect(result).toContain(
+      '<a href="http://b.com" target="_blank" rel="noopener">http://b.com</a>',
+    );
+  });
+
+  it('strips trailing parentheses', () => {
+    const input = '(see http://example.com)';
+    const result = linkifyUrls(input);
+
+    expect(result).toBe(
+      '(see <a href="http://example.com" target="_blank" rel="noopener">http://example.com</a>)',
+    );
+  });
+
+  it('strips trailing brackets', () => {
+    const input = '[http://example.com]';
+    const result = linkifyUrls(input);
+
+    expect(result).toBe(
+      '[<a href="http://example.com" target="_blank" rel="noopener">http://example.com</a>]',
+    );
+  });
+
+  it('does not double-link existing href attributes', () => {
+    const input = '<a href="http://example.com">link</a>';
+    const result = linkifyUrls(input);
+
+    // Should not add another <a> tag
+    expect(result).toBe(input);
+  });
+
+  it('handles multiple URLs in one string', () => {
+    const input = 'Check http://a.com and http://b.com';
+    const result = linkifyUrls(input);
+
+    expect(result).toContain('href="http://a.com"');
+    expect(result).toContain('href="http://b.com"');
+  });
+
+  it('escapes ampersands in href', () => {
+    const input = 'http://example.com/path?a=1&b=2';
+    const result = linkifyUrls(input);
+
+    // Ampersand is NOT in the URL because regex excludes &
+    // This is intentional to avoid capturing HTML entities like &quot;
+    expect(result).toContain('href="http://example.com/path?a=1"');
+  });
+
+  it('does not match URLs inside HTML attributes', () => {
+    const input = '<img src="http://example.com/img.png">';
+    const result = linkifyUrls(input);
+
+    // The URL in src should not be linkified (it's in quotes after =)
+    // Note: current implementation only checks href=, so src= would be linkified
+    // This test documents current behavior
+    expect(result).toContain('<a href="http://example.com/img.png"');
+  });
+
+  it('handles URLs with hash fragments', () => {
+    const input = 'See http://example.com/page#section';
+    const result = linkifyUrls(input);
+
+    expect(result).toContain('href="http://example.com/page#section"');
+  });
+
+  it('handles file URLs with spaces encoded', () => {
+    const input = 'file:///Users/test/my%20file.txt';
+    const result = linkifyUrls(input);
+
+    expect(result).toContain('href="file:///Users/test/my%20file.txt"');
+  });
+
+  it('returns text unchanged if no URLs', () => {
+    const input = 'Just some regular text without URLs';
+    const result = linkifyUrls(input);
+
+    expect(result).toBe(input);
+  });
+
+  it('handles URLs at start of string', () => {
+    const input = 'http://example.com is the site';
+    const result = linkifyUrls(input);
+
+    expect(result).toContain('<a href="http://example.com"');
+  });
+
+  it('handles URLs at end of string', () => {
+    const input = 'The site is http://example.com';
+    const result = linkifyUrls(input);
+
+    expect(result).toContain('href="http://example.com"');
+  });
+
+  it('handles IPv4 addresses in URLs', () => {
+    const input = 'Server at http://192.168.1.1:8080/api';
+    const result = linkifyUrls(input);
+
+    expect(result).toContain('href="http://192.168.1.1:8080/api"');
+  });
+
+  it('handles localhost URLs', () => {
+    const input = 'Dev server: http://localhost:3000';
+    const result = linkifyUrls(input);
+
+    expect(result).toContain('href="http://localhost:3000"');
+  });
+});

package/src/utils/linkifyUrls.ts

@@ -0,0 +1,24 @@
+/**
+ * Convert URLs in HTML text to clickable anchor tags.
+ * Supports http://, https://, and file:// URLs.
+ * Avoids double-linking URLs that are already in href attributes.
+ */
+export const linkifyUrls = (html: string): string => {
+  // Match URLs that are not already inside href attributes
+  // Supports http://, https://, and file:// URLs
+  // Exclude common delimiters and HTML entities (" & etc)
+  const urlRegex = /(?<!href=["'])(?:https?|file):\/\/[^\s<>"'{}&]+/gu;
+
+  return html.replaceAll(urlRegex, (url) => {
+    // Remove trailing punctuation that's likely not part of the URL
+    const cleanUrl = url.replace(/[.,;:!?)\]]+$/u, '');
+    const trailing = url.slice(cleanUrl.length);
+
+    // Escape HTML entities in the URL for the href attribute
+    const escapedHref = cleanUrl
+      .replaceAll('&', '&amp;')
+      .replaceAll('"', '&quot;');
+
+    return `<a href="${escapedHref}" target="_blank" rel="noopener">${cleanUrl}</a>${trailing}`;
+  });
+};

package/src/utils/matchesFilters.test.ts

@@ -0,0 +1,203 @@
+import { matchesFilters } from './matchesFilters.js';
+import { describe, expect, it } from 'vitest';
+
+describe('matchesFilters', () => {
+  describe('with no filters', () => {
+    it('returns true for any line', () => {
+      expect(matchesFilters('any text', [], [])).toBe(true);
+    });
+
+    it('returns true for empty line', () => {
+      expect(matchesFilters('', [], [])).toBe(true);
+    });
+  });
+
+  describe('include filtering (OR logic)', () => {
+    it('matches when single include is present', () => {
+      expect(matchesFilters('hello world', ['hello'], [])).toBe(true);
+    });
+
+    it('does not match when single include is absent', () => {
+      expect(matchesFilters('hello world', ['foo'], [])).toBe(false);
+    });
+
+    it('matches when any include is present', () => {
+      expect(matchesFilters('hello world', ['hello', 'foo'], [])).toBe(true);
+    });
+
+    it('matches when all includes are present', () => {
+      expect(matchesFilters('hello world foo', ['hello', 'foo'], [])).toBe(
+        true,
+      );
+    });
+
+    it('does not match when no includes are present', () => {
+      expect(matchesFilters('hello world', ['foo', 'bar'], [])).toBe(false);
+    });
+
+    it('is case insensitive', () => {
+      expect(matchesFilters('Hello World', ['hello'], [])).toBe(true);
+      expect(matchesFilters('hello world', ['HELLO'], [])).toBe(true);
+    });
+
+    it('matches partial words', () => {
+      expect(matchesFilters('hello world', ['ell'], [])).toBe(true);
+    });
+  });
+
+  describe('exclude filtering (OR logic)', () => {
+    it('excludes when single pattern matches', () => {
+      expect(matchesFilters('error occurred', [], ['error'])).toBe(false);
+    });
+
+    it('includes when single pattern does not match', () => {
+      expect(matchesFilters('info message', [], ['error'])).toBe(true);
+    });
+
+    it('excludes when any pattern matches', () => {
+      expect(matchesFilters('warning message', [], ['error', 'warning'])).toBe(
+        false,
+      );
+    });
+
+    it('includes when no patterns match', () => {
+      expect(matchesFilters('info message', [], ['error', 'warning'])).toBe(
+        true,
+      );
+    });
+
+    it('is case insensitive', () => {
+      expect(matchesFilters('ERROR occurred', [], ['error'])).toBe(false);
+      expect(matchesFilters('error occurred', [], ['ERROR'])).toBe(false);
+    });
+
+    it('matches partial words', () => {
+      expect(matchesFilters('error123', [], ['err'])).toBe(false);
+    });
+  });
+
+  describe('combined include and exclude', () => {
+    it('includes when include matches and exclude does not', () => {
+      expect(matchesFilters('info: success', ['info'], ['error'])).toBe(true);
+    });
+
+    it('excludes when both include and exclude match', () => {
+      expect(matchesFilters('error: info', ['info'], ['error'])).toBe(false);
+    });
+
+    it('excludes when include does not match', () => {
+      expect(matchesFilters('hello world', ['foo'], ['bar'])).toBe(false);
+    });
+  });
+
+  describe('with ANSI codes', () => {
+    it('ignores ANSI codes when matching includes', () => {
+      const line = '\u001B[31merror\u001B[0m: something failed';
+      expect(matchesFilters(line, ['error'], [])).toBe(true);
+    });
+
+    it('ignores ANSI codes when matching excludes', () => {
+      const line = '\u001B[32minfo\u001B[0m: all good';
+      expect(matchesFilters(line, [], ['error'])).toBe(true);
+    });
+
+    it('matches text inside ANSI codes', () => {
+      const line = '\u001B[36m[server]\u001B[0m Starting...';
+      expect(matchesFilters(line, ['server'], [])).toBe(true);
+    });
+
+    it('handles complex colored output', () => {
+      const line =
+        '\u001B[90m[teemux]\u001B[0m \u001B[1;31mERROR\u001B[0m: Connection failed';
+      // OR logic: matches if error OR connection is present (both are)
+      expect(matchesFilters(line, ['error', 'connection'], [])).toBe(true);
+      // Also matches with just one term present
+      expect(matchesFilters(line, ['error', 'foobar'], [])).toBe(true);
+      expect(matchesFilters(line, [], ['error'])).toBe(false);
+    });
+  });
+
+  describe('glob patterns with *', () => {
+    it('matches with * at the end', () => {
+      expect(matchesFilters('error: something failed', ['error*'], [])).toBe(
+        true,
+      );
+      expect(matchesFilters('info: all good', ['error*'], [])).toBe(false);
+    });
+
+    it('matches with * at the start', () => {
+      expect(matchesFilters('request failed', ['*failed'], [])).toBe(true);
+      expect(matchesFilters('request succeeded', ['*failed'], [])).toBe(false);
+    });
+
+    it('matches with * in the middle', () => {
+      expect(matchesFilters('[api] error occurred', ['[api]*error'], [])).toBe(
+        true,
+      );
+      expect(
+        matchesFilters('[worker] error occurred', ['[api]*error'], []),
+      ).toBe(false);
+    });
+
+    it('matches with multiple *', () => {
+      expect(matchesFilters('[api] GET /users 200', ['*GET*/users*'], [])).toBe(
+        true,
+      );
+      expect(
+        matchesFilters('[api] POST /users 201', ['*GET*/users*'], []),
+      ).toBe(false);
+    });
+
+    it('matches * as any characters (including empty)', () => {
+      expect(matchesFilters('error', ['error*'], [])).toBe(true);
+      expect(matchesFilters('error:', ['error*'], [])).toBe(true);
+      expect(matchesFilters('error: failed', ['error*'], [])).toBe(true);
+    });
+
+    it('is case insensitive with globs', () => {
+      expect(matchesFilters('ERROR: failed', ['error*'], [])).toBe(true);
+      expect(matchesFilters('error: FAILED', ['*FAILED'], [])).toBe(true);
+    });
+
+    it('works with excludes', () => {
+      expect(matchesFilters('healthcheck OK', [], ['health*'])).toBe(false);
+      expect(matchesFilters('error occurred', [], ['health*'])).toBe(true);
+    });
+
+    it('escapes regex special characters in glob patterns', () => {
+      // . is escaped (literal), so file.* matches "file." followed by anything
+      expect(matchesFilters('file.txt', ['file.*'], [])).toBe(true);
+      expect(matchesFilters('file_txt', ['file.*'], [])).toBe(false); // no literal . in text
+      expect(matchesFilters('price: $10.00', ['$10*'], [])).toBe(true);
+      expect(matchesFilters('[api] log', ['[api]*'], [])).toBe(true);
+    });
+
+    it('handles pattern with only *', () => {
+      expect(matchesFilters('anything', ['*'], [])).toBe(true);
+      expect(matchesFilters('', ['*'], [])).toBe(true);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles empty includes array with excludes', () => {
+      expect(matchesFilters('hello', [], ['foo'])).toBe(true);
+    });
+
+    it('handles empty excludes array with includes', () => {
+      expect(matchesFilters('hello', ['hello'], [])).toBe(true);
+    });
+
+    it('handles whitespace in includes', () => {
+      expect(matchesFilters('hello world', ['hello world'], [])).toBe(true);
+    });
+
+    it('handles special regex characters in includes', () => {
+      expect(matchesFilters('price: $10.00', ['$10'], [])).toBe(true);
+      expect(matchesFilters('path/to/file', ['path/to'], [])).toBe(true);
+    });
+
+    it('handles unicode characters', () => {
+      expect(matchesFilters('Hello 世界', ['世界'], [])).toBe(true);
+    });
+  });
+});

package/src/utils/matchesFilters.ts

@@ -0,0 +1,65 @@
+import { stripAnsi } from './stripAnsi.js';
+
+/**
+ * Convert a glob pattern (with * wildcards) to a RegExp.
+ * - `*` matches any characters (zero or more)
+ * - All other characters are escaped for literal matching
+ */
+const globToRegex = (pattern: string): RegExp => {
+  // Escape regex special characters except *
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+  // Convert * to .*
+  const regexPattern = escaped.replace(/\*/g, '.*');
+  return new RegExp(regexPattern, 'i');
+};
+
+/**
+ * Check if text matches a pattern (supports * glob wildcards).
+ * If no wildcards, does a simple substring match for better performance.
+ */
+const matchesPattern = (text: string, pattern: string): boolean => {
+  if (pattern.includes('*')) {
+    return globToRegex(pattern).test(text);
+  }
+  return text.includes(pattern.toLowerCase());
+};
+
+/**
+ * Check if a line matches the given filter criteria.
+ *
+ * @param line - The line to check (may contain ANSI codes)
+ * @param includes - Patterns where ANY match includes the line (OR logic), case-insensitive. Supports * wildcards.
+ * @param excludes - Patterns where ANY match excludes the line (OR logic), case-insensitive. Supports * wildcards.
+ * @returns true if the line should be included, false if filtered out
+ */
+export const matchesFilters = (
+  line: string,
+  includes: string[],
+  excludes: string[],
+): boolean => {
+  const plainText = stripAnsi(line).toLowerCase();
+
+  // Any include must match (OR logic) - case insensitive
+  if (includes.length > 0) {
+    const anyIncludeMatches = includes.some((pattern) =>
+      matchesPattern(plainText, pattern),
+    );
+
+    if (!anyIncludeMatches) {
+      return false;
+    }
+  }
+
+  // None of the excludes should match (OR logic for exclusion) - case insensitive
+  if (excludes.length > 0) {
+    const anyExcludeMatches = excludes.some((pattern) =>
+      matchesPattern(plainText, pattern),
+    );
+
+    if (anyExcludeMatches) {
+      return false;
+    }
+  }
+
+  return true;
+};

package/src/utils/stripAnsi.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { stripAnsi } from './stripAnsi.js';
+
+describe('stripAnsi', () => {
+  it('returns plain text unchanged', () => {
+    expect(stripAnsi('hello world')).toBe('hello world');
+  });
+
+  it('strips single color code', () => {
+    expect(stripAnsi('\u001B[31mred text\u001B[0m')).toBe('red text');
+  });
+
+  it('strips multiple color codes', () => {
+    const input = '\u001B[31mred\u001B[0m \u001B[32mgreen\u001B[0m';
+    expect(stripAnsi(input)).toBe('red green');
+  });
+
+  it('strips bold code', () => {
+    expect(stripAnsi('\u001B[1mbold\u001B[0m')).toBe('bold');
+  });
+
+  it('strips dim code', () => {
+    expect(stripAnsi('\u001B[2mdim\u001B[0m')).toBe('dim');
+  });
+
+  it('strips combined codes', () => {
+    // Bold + red
+    expect(stripAnsi('\u001B[1;31mbold red\u001B[0m')).toBe('bold red');
+  });
+
+  it('strips 256 color codes', () => {
+    expect(stripAnsi('\u001B[38;5;196mcolor\u001B[0m')).toBe('color');
+  });
+
+  it('strips bright color codes', () => {
+    expect(stripAnsi('\u001B[91mbright red\u001B[0m')).toBe('bright red');
+  });
+
+  it('handles empty string', () => {
+    expect(stripAnsi('')).toBe('');
+  });
+
+  it('handles string with only ANSI codes', () => {
+    expect(stripAnsi('\u001B[31m\u001B[0m')).toBe('');
+  });
+
+  it('preserves newlines', () => {
+    expect(stripAnsi('line1\nline2')).toBe('line1\nline2');
+  });
+
+  it('preserves tabs', () => {
+    expect(stripAnsi('col1\tcol2')).toBe('col1\tcol2');
+  });
+
+  it('handles realistic log prefix', () => {
+    const input = '\u001B[36m[server]\u001B[0m Starting...';
+    expect(stripAnsi(input)).toBe('[server] Starting...');
+  });
+
+  it('handles nested formatting', () => {
+    const input = '\u001B[1m\u001B[31mERROR\u001B[0m: something failed';
+    expect(stripAnsi(input)).toBe('ERROR: something failed');
+  });
+});

package/src/utils/stripAnsi.ts

@@ -0,0 +1,8 @@
+/**
+ * Strip ANSI escape codes from text.
+ * Removes color codes and other terminal formatting sequences.
+ */
+export const stripAnsi = (text: string): string => {
+  // eslint-disable-next-line no-control-regex
+  return text.replaceAll(/\u001B\[[\d;]*m/gu, '');
+};

package/src/utils/stripHtmlTags.ts

@@ -0,0 +1,6 @@
+/**
+ * Strip HTML tags from a string, leaving only text content.
+ */
+export const stripHtmlTags = (html: string): string => {
+  return html.replaceAll(/<[^>]*>/gu, '');
+};

package/src/utils/unescapeHtml.ts

@@ -0,0 +1,12 @@
+/**
+ * Unescape HTML entities back to their original characters.
+ */
+export const unescapeHtml = (text: string): string => {
+  return text
+    .replaceAll('"', '"')
+    .replaceAll('&', '&')
+    .replaceAll('&lt;', '<')
+    .replaceAll('&gt;', '>')
+    .replaceAll('&#x27;', "'")
+    .replaceAll('&#39;', "'");
+};