claw-dashboard 1.9.0 → 2.1.0

package/tests/utils.js

@@ -0,0 +1,242 @@
+/**
+ * Test utilities extracted from index.js
+ * These are pure functions that can be unit tested without the Dashboard class
+ */
+
+import os from 'os';
+import { resolve, join } from 'path';
+
+// Color constants (same as in index.js)
+const C = {
+  green: 'green', brightGreen: 'bright-green',
+  yellow: 'yellow', brightYellow: 'bright-yellow',
+  red: 'red', brightRed: 'bright-red',
+  cyan: 'cyan', brightCyan: 'bright-cyan',
+  magenta: 'magenta', brightMagenta: 'bright-magenta',
+  blue: 'blue', brightBlue: 'bright-blue',
+  white: 'white', brightWhite: 'bright-white',
+  gray: 'gray', black: 'black'
+};
+
+/**
+ * Generate a gauge bar visualization
+ * @param {number} percent - Percentage (0-100)
+ * @param {number} width - Width of the gauge in characters
+ * @returns {string} Gauge visualization
+ */
+function gauge(percent, width = 15) {
+  const filled = Math.round((percent / 100) * width);
+  return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+
+/**
+ * Generate a sparkline from data points
+ * @param {number[]} data - Array of numeric values
+ * @param {number} width - Max width of sparkline
+ * @returns {string} Sparkline visualization
+ */
+function sparkline(data, width = 15) {
+  if (!data || data.length === 0) return '─'.repeat(width);
+  const chars = '▁▂▃▄▅▆▇█';
+  const max = Math.max(...data, 1);
+  const recent = data.slice(-width);
+  return recent.map(v => {
+    const normalized = Math.max(0, Math.min(1, v / max));
+    return chars[Math.floor(normalized * (chars.length - 1))];
+  }).join('');
+}
+
+/**
+ * Get color based on percentage threshold
+ * @param {number} percent - Percentage value
+ * @returns {string} Color name
+ */
+function getColor(percent) {
+  if (percent >= 80) return C.red;
+  if (percent >= 60) return C.yellow;
+  return C.green;
+}
+
+/**
+ * Format bytes to human-readable string
+ * @param {number} bytes - Number of bytes
+ * @returns {string} Formatted string (e.g., "1.5 GB")
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+}
+
+/**
+ * Format bytes per second to bits per second
+ * @param {number} bytesPerSec - Bytes per second
+ * @returns {string} Formatted string (e.g., "1.5M")
+ */
+function formatBitsPerSecond(bytesPerSec) {
+  const bitsPerSec = bytesPerSec * 8;
+  if (bitsPerSec === 0) return '0';
+  if (bitsPerSec < 1000) return Math.round(bitsPerSec) + 'b';
+  if (bitsPerSec < 1000000) return (bitsPerSec / 1000).toFixed(0) + 'K';
+  return (bitsPerSec / 1000000).toFixed(1) + 'M';
+}
+
+/**
+ * Format duration in seconds to human-readable string
+ * @param {number} seconds - Duration in seconds
+ * @returns {string} Formatted duration (e.g., "2d 3h")
+ */
+function formatDuration(seconds) {
+  if (!seconds || seconds < 0) return '--';
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  if (days > 0) return `${days}d ${hours}h`;
+  if (hours > 0) return `${hours}h ${mins}m`;
+  return `${mins}m`;
+}
+
+/**
+ * Calculate tokens per second between two sessions
+ * @param {object} session - Current session
+ * @param {object} prevSession - Previous session
+ * @param {number} elapsedMs - Elapsed time in milliseconds
+ * @returns {number|null} Tokens per second or null
+ */
+function calcTPS(session, prevSession, elapsedMs) {
+  if (!session || !prevSession || elapsedMs < 100) return null;
+  const currTokens = session.totalTokens || 0;
+  const prevTokens = prevSession.totalTokens || 0;
+  const diff = currTokens - prevTokens;
+  if (diff <= 0) return null;
+  const tps = diff / (elapsedMs / 1000);
+  return tps > 0 ? parseFloat(tps.toFixed(1)) : null;
+}
+
+/**
+ * Validate file path for security
+ * @param {string} filePath - Path to validate
+ * @param {string[]} allowedDirs - Additional allowed directories
+ * @returns {object} Validation result
+ */
+function validateFilePath(filePath, allowedDirs = []) {
+  try {
+    if (!filePath || typeof filePath !== 'string') {
+      return { valid: false, resolvedPath: filePath, error: "Invalid file path" };
+    }
+
+    const normalizedPath = filePath.startsWith('~')
+      ? join(os.homedir(), filePath.slice(1))
+      : filePath;
+
+    const resolvedPath = resolve(normalizedPath);
+
+    if (filePath.includes("..")) {
+      return { valid: false, resolvedPath, error: "Path traversal not allowed" };
+    }
+
+    const homeDir = os.homedir();
+    const defaultAllowedDirs = [
+      homeDir,
+      homeDir + "/.openclaw",
+      homeDir + "/.openclaw/agents",
+      "/tmp"
+    ];
+
+    const allAllowedDirs = [...defaultAllowedDirs, ...allowedDirs];
+
+    const isAllowed = allAllowedDirs.some(allowedDir => {
+      const resolvedAllowed = resolve(allowedDir);
+      return resolvedPath.startsWith(resolvedAllowed + "/") || resolvedPath === resolvedAllowed;
+    });
+
+    if (!isAllowed) {
+      return { valid: false, resolvedPath, error: "Path not in allowed directories" };
+    }
+
+    return { valid: true, resolvedPath };
+  } catch (err) {
+    return { valid: false, resolvedPath: filePath, error: err.message };
+  }
+}
+
+/**
+ * Colorize log line based on log level
+ * @param {string} line - Log line to colorize
+ * @returns {string} Colorized log line
+ */
+function colorizeLogLine(line) {
+  if (!line || typeof line !== 'string') return line;
+  
+  let matchedLevel = null;
+  let levelStart = -1;
+  let levelEnd = -1;
+  
+  for (const level of ['error', 'warn', 'info', 'debug']) {
+    const escapedLevel = level.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`\\[${escapedLevel.toUpperCase()}\\]`, 'i');
+    const match = line.match(pattern);
+    if (match) {
+      matchedLevel = level;
+      levelStart = match.index;
+      levelEnd = levelStart + match[0].length;
+      break;
+    }
+  }
+  
+  if (!matchedLevel) {
+    for (const level of ['error', 'warn', 'info', 'debug']) {
+      const escapedLevel = level.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const pattern = new RegExp(`^\\d{4}-\\d{2}-\\d{2}[T ].*?${escapedLevel}:`, 'i');
+      const match = line.match(pattern);
+      if (match) {
+        matchedLevel = level;
+        levelStart = match.index;
+        const afterMatch = line.slice(match.index + match[0].length);
+        const spaceMatch = afterMatch.match(/^(\s*)/);
+        levelEnd = match.index + match[0].length + (spaceMatch ? spaceMatch[1].length : 0);
+        break;
+      }
+    }
+  }
+  
+  if (!matchedLevel) return line;
+  
+  const LOG_COLORS = {
+    error: C.brightRed,
+    warn: C.brightYellow,
+    info: C.cyan,
+    debug: C.gray
+  };
+  
+  const color = LOG_COLORS[matchedLevel] || C.white;
+  const colorTag = `{${color}-fg}`;
+  const resetTag = '{/}';
+  
+  return line.slice(0, levelStart) + colorTag + line.slice(levelStart, levelEnd) + resetTag + line.slice(levelEnd);
+}
+
+/**
+ * Convert camelCase to dash-case for tag colors
+ * @param {string} color - Color name in camelCase
+ * @returns {string} Color name in dash-case
+ */
+function toTagColor(color) {
+  return color.replace(/([A-Z])/g, '-$1').toLowerCase();
+}
+
+export {
+  C,
+  gauge,
+  sparkline,
+  getColor,
+  formatBytes,
+  formatBitsPerSecond,
+  formatDuration,
+  calcTPS,
+  validateFilePath,
+  colorizeLogLine,
+  toTagColor
+};

package/tests/utils.test.js

@@ -0,0 +1,317 @@
+/**
+ * Unit tests for utility functions
+ */
+
+import {
+  gauge,
+  sparkline,
+  getColor,
+  formatBytes,
+  formatBitsPerSecond,
+  formatDuration,
+  calcTPS,
+  validateFilePath,
+  colorizeLogLine,
+  toTagColor
+} from './utils.js';
+
+describe('gauge', () => {
+  test('returns empty gauge for 0%', () => {
+    const result = gauge(0, 10);
+    expect(result).toBe('░'.repeat(10));
+  });
+
+  test('returns full gauge for 100%', () => {
+    const result = gauge(100, 10);
+    expect(result).toBe('█'.repeat(10));
+  });
+
+  test('returns half gauge for 50%', () => {
+    const result = gauge(50, 10);
+    expect(result).toBe('█'.repeat(5) + '░'.repeat(5));
+  });
+
+  test('handles decimal percentages correctly', () => {
+    const result = gauge(33, 10);
+    // 33% of 10 = 3.3 rounded = 3 filled
+    expect(result.startsWith('███')).toBe(true);
+  });
+
+  test('defaults to width 15', () => {
+    const result = gauge(50);
+    expect(result.length).toBe(15);
+  });
+
+  test('handles boundary values', () => {
+    expect(gauge(1, 10).length).toBe(10);
+    expect(gauge(99, 10).length).toBe(10);
+  });
+});
+
+describe('sparkline', () => {
+  test('returns dashes for empty array', () => {
+    const result = sparkline([]);
+    expect(result).toBe('─'.repeat(15));
+  });
+
+  test('returns dashes for null/undefined', () => {
+    expect(sparkline(null)).toBe('─'.repeat(15));
+    expect(sparkline(undefined)).toBe('─'.repeat(15));
+  });
+
+  test('returns single character for single value', () => {
+    const result = sparkline([100], 10);
+    expect(result.length).toBe(1);
+    expect(result).toBe('█');
+  });
+
+  test('handles increasing values', () => {
+    const data = [10, 20, 30, 40, 50];
+    const result = sparkline(data, 5);
+    expect(result.length).toBe(5);
+  });
+
+  test('handles decreasing values', () => {
+    const data = [50, 40, 30, 20, 10];
+    const result = sparkline(data, 5);
+    expect(result.length).toBe(5);
+  });
+
+  test('uses only recent data when array is larger than width', () => {
+    const data = Array.from({ length: 30 }, (_, i) => i * 10);
+    const result = sparkline(data, 10);
+    expect(result.length).toBe(10);
+  });
+
+  test('handles all same values', () => {
+    const data = [50, 50, 50, 50, 50];
+    const result = sparkline(data, 5);
+    // Should use middle character for 50% value
+    expect(result.length).toBe(5);
+  });
+});
+
+describe('getColor', () => {
+  test('returns green for low percentages', () => {
+    expect(getColor(0)).toBe('green');
+    expect(getColor(30)).toBe('green');
+    expect(getColor(59)).toBe('green');
+  });
+
+  test('returns yellow for medium percentages', () => {
+    expect(getColor(60)).toBe('yellow');
+    expect(getColor(70)).toBe('yellow');
+    expect(getColor(79)).toBe('yellow');
+  });
+
+  test('returns red for high percentages', () => {
+    expect(getColor(80)).toBe('red');
+    expect(getColor(90)).toBe('red');
+    expect(getColor(100)).toBe('red');
+  });
+});
+
+describe('formatBytes', () => {
+  test('formats 0 bytes', () => {
+    expect(formatBytes(0)).toBe('0 B');
+  });
+
+  test('formats bytes correctly', () => {
+    expect(formatBytes(512)).toBe('512 B');
+    expect(formatBytes(1023)).toBe('1023 B');
+  });
+
+  test('formats kilobytes correctly', () => {
+    expect(formatBytes(1024)).toBe('1 KB');
+    expect(formatBytes(1536)).toBe('1.5 KB');
+    expect(formatBytes(10240)).toBe('10 KB');
+  });
+
+  test('formats megabytes correctly', () => {
+    expect(formatBytes(1048576)).toBe('1 MB');
+    expect(formatBytes(1572864)).toBe('1.5 MB');
+  });
+
+  test('formats gigabytes correctly', () => {
+    expect(formatBytes(1073741824)).toBe('1 GB');
+  });
+
+  test('handles large values', () => {
+    const result = formatBytes(5000000000);
+    expect(result).toContain('GB');
+  });
+});
+
+describe('formatBitsPerSecond', () => {
+  test('formats 0 bps', () => {
+    expect(formatBitsPerSecond(0)).toBe('0');
+  });
+
+  test('formats bits correctly', () => {
+    expect(formatBitsPerSecond(1)).toBe('8b');
+    expect(formatBitsPerSecond(100)).toBe('800b');
+    expect(formatBitsPerSecond(125)).toBe('1K');
+  });
+
+  test('formats kilobits correctly', () => {
+    expect(formatBitsPerSecond(125)).toBe('1K');
+    expect(formatBitsPerSecond(1250)).toBe('10K');
+  });
+
+  test('formats megabits correctly', () => {
+    expect(formatBitsPerSecond(125000)).toBe('1.0M');
+    expect(formatBitsPerSecond(1250000)).toBe('10.0M');
+  });
+});
+
+describe('formatDuration', () => {
+  test('returns -- for null/undefined', () => {
+    expect(formatDuration(null)).toBe('--');
+    expect(formatDuration(undefined)).toBe('--');
+  });
+
+  test('returns -- for negative values', () => {
+    expect(formatDuration(-1)).toBe('--');
+  });
+
+  test('formats minutes correctly', () => {
+    expect(formatDuration(60)).toBe('1m');
+    expect(formatDuration(300)).toBe('5m');
+    expect(formatDuration(3599)).toBe('59m');
+  });
+
+  test('formats hours correctly', () => {
+    expect(formatDuration(3600)).toBe('1h 0m');
+    expect(formatDuration(7200)).toBe('2h 0m');
+    expect(formatDuration(3660)).toBe('1h 1m');
+  });
+
+  test('formats days correctly', () => {
+    expect(formatDuration(86400)).toBe('1d 0h');
+    expect(formatDuration(90000)).toBe('1d 1h');
+    expect(formatDuration(172800)).toBe('2d 0h');
+  });
+});
+
+describe('calcTPS', () => {
+  test('returns null for missing sessions', () => {
+    expect(calcTPS(null, {}, 1000)).toBeNull();
+    expect(calcTPS({}, null, 1000)).toBeNull();
+    expect(calcTPS({}, {}, 1000)).toBeNull();
+  });
+
+  test('returns null for elapsed time less than 100ms', () => {
+    const session = { totalTokens: 100 };
+    const prevSession = { totalTokens: 0 };
+    expect(calcTPS(session, prevSession, 50)).toBeNull();
+    expect(calcTPS(session, prevSession, 99)).toBeNull();
+  });
+
+  test('returns null when tokens decreased', () => {
+    const session = { totalTokens: 50 };
+    const prevSession = { totalTokens: 100 };
+    expect(calcTPS(session, prevSession, 1000)).toBeNull();
+  });
+
+  test('returns null when tokens are equal', () => {
+    const session = { totalTokens: 100 };
+    const prevSession = { totalTokens: 100 };
+    expect(calcTPS(session, prevSession, 1000)).toBeNull();
+  });
+
+  test('calculates TPS correctly', () => {
+    const session = { totalTokens: 1000 };
+    const prevSession = { totalTokens: 0 };
+    // 1000 tokens in 1 second = 1000 TPS
+    const result = calcTPS(session, prevSession, 1000);
+    expect(result).toBe(1000);
+  });
+
+  test('handles missing totalTokens property (defaults to 0)', () => {
+    const session = {};
+    const prevSession = {};
+    expect(calcTPS(session, prevSession, 1000)).toBeNull(); // 0 - 0 = 0, so null
+  });
+});
+
+describe('validateFilePath', () => {
+  // Note: validateFilePath now uses ESM imports instead of require()
+  // These tests verify basic behavior
+
+  test('rejects null/undefined paths', () => {
+    expect(validateFilePath(null).valid).toBe(false);
+    expect(validateFilePath(undefined).valid).toBe(false);
+    expect(validateFilePath('').valid).toBe(false);
+  });
+
+  test('rejects path traversal attempts', () => {
+    // This works because it checks for ".." in the path
+    const result = validateFilePath('/home/user/../../../etc/passwd');
+    expect(result.valid).toBe(false);
+  });
+
+  test('rejects paths outside allowed directories', () => {
+    const result = validateFilePath('/usr/bin/test');
+    expect(result.valid).toBe(false);
+  });
+});
+
+describe('colorizeLogLine', () => {
+  test('returns unchanged for null/undefined', () => {
+    expect(colorizeLogLine(null)).toBeNull();
+    expect(colorizeLogLine(undefined)).toBeUndefined();
+  });
+
+  test('returns unchanged for non-string', () => {
+    expect(colorizeLogLine(123)).toBe(123);
+  });
+
+  test('colorizes error lines with brackets', () => {
+    const line = '[ERROR] Something went wrong';
+    const result = colorizeLogLine(line);
+    expect(result).toContain('{bright-red-fg}');
+    expect(result).toContain('{/}');
+  });
+
+  test('colorizes warn lines with brackets', () => {
+    const line = '[WARN] Warning message';
+    const result = colorizeLogLine(line);
+    expect(result).toContain('{bright-yellow-fg}');
+  });
+
+  test('colorizes info lines with brackets', () => {
+    const line = '[INFO] Info message';
+    const result = colorizeLogLine(line);
+    expect(result).toContain('{cyan-fg}');
+  });
+
+  test('colorizes debug lines with brackets', () => {
+    const line = '[DEBUG] Debug message';
+    const result = colorizeLogLine(line);
+    expect(result).toContain('{gray-fg}');
+  });
+
+  test('handles lowercase brackets', () => {
+    const line = '[error] Lowercase error';
+    const result = colorizeLogLine(line);
+    expect(result).toContain('{bright-red-fg}');
+  });
+
+  test('returns unchanged for lines without log levels', () => {
+    const line = 'Just a regular message';
+    const result = colorizeLogLine(line);
+    expect(result).toBe(line);
+  });
+});
+
+describe('toTagColor', () => {
+  test('converts camelCase to dash-case', () => {
+    expect(toTagColor('brightRed')).toBe('bright-red');
+    expect(toTagColor('brightGreen')).toBe('bright-green');
+    expect(toTagColor('brightYellow')).toBe('bright-yellow');
+  });
+
+  test('handles single words', () => {
+    expect(toTagColor('red')).toBe('red');
+  });
+});