claw-dashboard 2.1.1 → 2.2.0

package/tests/utils.js

@@ -1,242 +0,0 @@
-/**
- * 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

@@ -1,317 +0,0 @@
-/**
- * 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');
-  });
-});