@jetstart/logs 1.5.2

package/src/server/storage.ts

@@ -0,0 +1,77 @@
+/**
+ * Log Storage
+ * In-memory log storage with size limits
+ */
+
+import { LogEntry, LogLevel, LogSource, LogStats } from '@jetstart/shared';
+
+export class LogStorage {
+  private logs: LogEntry[] = [];
+  private maxEntries: number;
+
+  constructor(maxEntries: number = 10000) {
+    this.maxEntries = maxEntries;
+  }
+
+  add(entry: LogEntry): void {
+    this.logs.push(entry);
+
+    // Trim if exceeds max
+    if (this.logs.length > this.maxEntries) {
+      this.logs.shift();
+    }
+  }
+
+  getAll(): LogEntry[] {
+    return [...this.logs];
+  }
+
+  clear(): void {
+    this.logs = [];
+  }
+
+  getStats(): LogStats {
+    const stats: LogStats = {
+      totalLogs: this.logs.length,
+      errorCount: 0,
+      warningCount: 0,
+      lastLogTime: this.logs.length > 0 ? this.logs[this.logs.length - 1].timestamp : 0,
+      logsByLevel: {
+        [LogLevel.VERBOSE]: 0,
+        [LogLevel.DEBUG]: 0,
+        [LogLevel.INFO]: 0,
+        [LogLevel.WARN]: 0,
+        [LogLevel.ERROR]: 0,
+        [LogLevel.FATAL]: 0,
+      },
+      logsBySource: {
+        [LogSource.CLI]: 0,
+        [LogSource.CORE]: 0,
+        [LogSource.CLIENT]: 0,
+        [LogSource.BUILD]: 0,
+        [LogSource.NETWORK]: 0,
+        [LogSource.SYSTEM]: 0,
+      },
+    };
+
+    this.logs.forEach(log => {
+      // Count by level
+      stats.logsByLevel[log.level]++;
+
+      // Count errors and warnings
+      if (log.level === LogLevel.ERROR || log.level === LogLevel.FATAL) {
+        stats.errorCount++;
+      }
+      if (log.level === LogLevel.WARN) {
+        stats.warningCount++;
+      }
+
+      // Count by source
+      if (log.source in stats.logsBySource) {
+        stats.logsBySource[log.source]++;
+      }
+    });
+
+    return stats;
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Logs-specific types
+ */
+
+export interface LogViewerOptions {
+  follow?: boolean;
+  tail?: number;
+  filter?: any;
+}
+
+export interface LogServerStats {
+  totalLogs: number;
+  activeClients: number;
+  uptime: number;
+}

package/src/utils/colors.ts

@@ -0,0 +1,45 @@
+/**
+ * Color Utilities
+ * Colors for different log levels and sources
+ */
+
+import chalk from 'chalk';
+import { LogLevel, LogSource } from '@jetstart/shared';
+
+export function getColorForLevel(level: LogLevel): chalk.Chalk {
+  switch (level) {
+    case LogLevel.VERBOSE:
+      return chalk.gray;
+    case LogLevel.DEBUG:
+      return chalk.blue;
+    case LogLevel.INFO:
+      return chalk.green;
+    case LogLevel.WARN:
+      return chalk.yellow;
+    case LogLevel.ERROR:
+      return chalk.red;
+    case LogLevel.FATAL:
+      return chalk.bgRed.white;
+    default:
+      return chalk.white;
+  }
+}
+
+export function getColorForSource(source: LogSource): chalk.Chalk {
+  switch (source) {
+    case LogSource.CLI:
+      return chalk.cyan;
+    case LogSource.CORE:
+      return chalk.magenta;
+    case LogSource.CLIENT:
+      return chalk.green;
+    case LogSource.BUILD:
+      return chalk.yellow;
+    case LogSource.NETWORK:
+      return chalk.blue;
+    case LogSource.SYSTEM:
+      return chalk.gray;
+    default:
+      return chalk.white;
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Export all utilities
+ */
+
+export * from './colors';

package/tests/filters.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Tests for log filters
+ */
+
+import { filterByLevel, filterBySource, filterBySearch, applyFilters } from '../src/filters';
+import { LogEntry, LogLevel, LogSource } from '@jetstart/shared';
+
+describe('Log Filters', () => {
+  const sampleLogs: LogEntry[] = [
+    {
+      id: '1',
+      timestamp: Date.now(),
+      level: LogLevel.INFO,
+      tag: 'Test',
+      message: 'Info message',
+      source: LogSource.CLI,
+    },
+    {
+      id: '2',
+      timestamp: Date.now(),
+      level: LogLevel.ERROR,
+      tag: 'Test',
+      message: 'Error message',
+      source: LogSource.BUILD,
+    },
+    {
+      id: '3',
+      timestamp: Date.now(),
+      level: LogLevel.WARN,
+      tag: 'Test',
+      message: 'Warning message',
+      source: LogSource.CORE,
+    },
+  ];
+
+  describe('filterByLevel', () => {
+    it('should filter logs by level', () => {
+      const filtered = filterByLevel(sampleLogs, [LogLevel.ERROR]);
+      expect(filtered.length).toBe(1);
+      expect(filtered[0].level).toBe(LogLevel.ERROR);
+    });
+
+    it('should filter by multiple levels', () => {
+      const filtered = filterByLevel(sampleLogs, [LogLevel.ERROR, LogLevel.WARN]);
+      expect(filtered.length).toBe(2);
+    });
+  });
+
+  describe('filterBySource', () => {
+    it('should filter logs by source', () => {
+      const filtered = filterBySource(sampleLogs, [LogSource.BUILD]);
+      expect(filtered.length).toBe(1);
+      expect(filtered[0].source).toBe(LogSource.BUILD);
+    });
+  });
+
+  describe('filterBySearch', () => {
+    it('should search in message', () => {
+      const filtered = filterBySearch(sampleLogs, 'error');
+      expect(filtered.length).toBe(1);
+      expect(filtered[0].message).toContain('Error');
+    });
+
+    it('should be case-insensitive', () => {
+      const filtered = filterBySearch(sampleLogs, 'ERROR');
+      expect(filtered.length).toBe(1);
+    });
+  });
+
+  describe('applyFilters', () => {
+    it('should apply multiple filters', () => {
+      const filtered = applyFilters(sampleLogs, {
+        levels: [LogLevel.ERROR, LogLevel.WARN],
+        sources: [LogSource.BUILD],
+      });
+      expect(filtered.length).toBe(1);
+      expect(filtered[0].level).toBe(LogLevel.ERROR);
+      expect(filtered[0].source).toBe(LogSource.BUILD);
+    });
+  });
+});

package/tests/storage.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Tests for log storage
+ */
+
+import { LogStorage } from '../src/server/storage';
+import { LogEntry, LogLevel, LogSource } from '@jetstart/shared';
+
+describe('LogStorage', () => {
+  let storage: LogStorage;
+
+  beforeEach(() => {
+    storage = new LogStorage(100);
+  });
+
+  it('should add and retrieve logs', () => {
+    const log: LogEntry = {
+      id: '1',
+      timestamp: Date.now(),
+      level: LogLevel.INFO,
+      tag: 'Test',
+      message: 'Test message',
+      source: LogSource.CLI,
+    };
+
+    storage.add(log);
+    const logs = storage.getAll();
+
+    expect(logs.length).toBe(1);
+    expect(logs[0]).toEqual(log);
+  });
+
+  it('should enforce max entries limit', () => {
+    const smallStorage = new LogStorage(5);
+
+    for (let i = 0; i < 10; i++) {
+      smallStorage.add({
+        id: String(i),
+        timestamp: Date.now(),
+        level: LogLevel.INFO,
+        tag: 'Test',
+        message: `Message ${i}`,
+        source: LogSource.CLI,
+      });
+    }
+
+    const logs = smallStorage.getAll();
+    expect(logs.length).toBe(5);
+    expect(logs[0].id).toBe('5'); // First 5 removed
+  });
+
+  it('should clear all logs', () => {
+    storage.add({
+      id: '1',
+      timestamp: Date.now(),
+      level: LogLevel.INFO,
+      tag: 'Test',
+      message: 'Test',
+      source: LogSource.CLI,
+    });
+
+    storage.clear();
+    expect(storage.getAll().length).toBe(0);
+  });
+
+  it('should generate statistics', () => {
+    storage.add({
+      id: '1',
+      timestamp: Date.now(),
+      level: LogLevel.ERROR,
+      tag: 'Test',
+      message: 'Error',
+      source: LogSource.BUILD,
+    });
+
+    storage.add({
+      id: '2',
+      timestamp: Date.now(),
+      level: LogLevel.WARN,
+      tag: 'Test',
+      message: 'Warning',
+      source: LogSource.CORE,
+    });
+
+    const stats = storage.getStats();
+    expect(stats.totalLogs).toBe(2);
+    expect(stats.errorCount).toBe(1);
+    expect(stats.warningCount).toBe(1);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "composite": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "references": [
+    { "path": "../shared" }
+  ],
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}