@jetstart/logs 1.5.2

package/dist/server/storage.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Log Storage
+ * In-memory log storage with size limits
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogStorage = void 0;
+const shared_1 = require("@jetstart/shared");
+class LogStorage {
+    logs = [];
+    maxEntries;
+    constructor(maxEntries = 10000) {
+        this.maxEntries = maxEntries;
+    }
+    add(entry) {
+        this.logs.push(entry);
+        // Trim if exceeds max
+        if (this.logs.length > this.maxEntries) {
+            this.logs.shift();
+        }
+    }
+    getAll() {
+        return [...this.logs];
+    }
+    clear() {
+        this.logs = [];
+    }
+    getStats() {
+        const stats = {
+            totalLogs: this.logs.length,
+            errorCount: 0,
+            warningCount: 0,
+            lastLogTime: this.logs.length > 0 ? this.logs[this.logs.length - 1].timestamp : 0,
+            logsByLevel: {
+                [shared_1.LogLevel.VERBOSE]: 0,
+                [shared_1.LogLevel.DEBUG]: 0,
+                [shared_1.LogLevel.INFO]: 0,
+                [shared_1.LogLevel.WARN]: 0,
+                [shared_1.LogLevel.ERROR]: 0,
+                [shared_1.LogLevel.FATAL]: 0,
+            },
+            logsBySource: {
+                [shared_1.LogSource.CLI]: 0,
+                [shared_1.LogSource.CORE]: 0,
+                [shared_1.LogSource.CLIENT]: 0,
+                [shared_1.LogSource.BUILD]: 0,
+                [shared_1.LogSource.NETWORK]: 0,
+                [shared_1.LogSource.SYSTEM]: 0,
+            },
+        };
+        this.logs.forEach(log => {
+            // Count by level
+            stats.logsByLevel[log.level]++;
+            // Count errors and warnings
+            if (log.level === shared_1.LogLevel.ERROR || log.level === shared_1.LogLevel.FATAL) {
+                stats.errorCount++;
+            }
+            if (log.level === shared_1.LogLevel.WARN) {
+                stats.warningCount++;
+            }
+            // Count by source
+            if (log.source in stats.logsBySource) {
+                stats.logsBySource[log.source]++;
+            }
+        });
+        return stats;
+    }
+}
+exports.LogStorage = LogStorage;
+//# sourceMappingURL=storage.js.map

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Logs-specific types
+ */
+export interface LogViewerOptions {
+    follow?: boolean;
+    tail?: number;
+    filter?: any;
+}
+export interface LogServerStats {
+    totalLogs: number;
+    activeClients: number;
+    uptime: number;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Logs-specific types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/utils/colors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Color Utilities
+ * Colors for different log levels and sources
+ */
+import chalk from 'chalk';
+import { LogLevel, LogSource } from '@jetstart/shared';
+export declare function getColorForLevel(level: LogLevel): chalk.Chalk;
+export declare function getColorForSource(source: LogSource): chalk.Chalk;
+//# sourceMappingURL=colors.d.ts.map

package/dist/utils/colors.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Color Utilities
+ * Colors for different log levels and sources
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColorForLevel = getColorForLevel;
+exports.getColorForSource = getColorForSource;
+const chalk_1 = __importDefault(require("chalk"));
+const shared_1 = require("@jetstart/shared");
+function getColorForLevel(level) {
+    switch (level) {
+        case shared_1.LogLevel.VERBOSE:
+            return chalk_1.default.gray;
+        case shared_1.LogLevel.DEBUG:
+            return chalk_1.default.blue;
+        case shared_1.LogLevel.INFO:
+            return chalk_1.default.green;
+        case shared_1.LogLevel.WARN:
+            return chalk_1.default.yellow;
+        case shared_1.LogLevel.ERROR:
+            return chalk_1.default.red;
+        case shared_1.LogLevel.FATAL:
+            return chalk_1.default.bgRed.white;
+        default:
+            return chalk_1.default.white;
+    }
+}
+function getColorForSource(source) {
+    switch (source) {
+        case shared_1.LogSource.CLI:
+            return chalk_1.default.cyan;
+        case shared_1.LogSource.CORE:
+            return chalk_1.default.magenta;
+        case shared_1.LogSource.CLIENT:
+            return chalk_1.default.green;
+        case shared_1.LogSource.BUILD:
+            return chalk_1.default.yellow;
+        case shared_1.LogSource.NETWORK:
+            return chalk_1.default.blue;
+        case shared_1.LogSource.SYSTEM:
+            return chalk_1.default.gray;
+        default:
+            return chalk_1.default.white;
+    }
+}
+//# sourceMappingURL=colors.js.map

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Export all utilities
+ */
+export * from './colors';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Export all utilities
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./colors"), exports);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@jetstart/logs",
+  "version": "1.5.2",
+  "description": "Logging service for JetStart",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./server": "./dist/server/index.js",
+    "./cli": "./dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/server/index.js",
+    "start:dev": "ts-node src/server/index.ts",
+    "clean": "rm -rf dist",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "jetstart",
+    "logs",
+    "logging",
+    "logcat"
+  ],
+  "author": "Phantom",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@jetstart/shared": "^1.5.2",
+    "ws": "^8.14.2",
+    "chalk": "^4.1.2",
+    "date-fns": "^2.30.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.10",
+    "@types/node": "^20.10.0",
+    "@types/jest": "^29.5.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=9.0.0"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "roots": [
+      "<rootDir>/tests"
+    ],
+    "testMatch": [
+      "**/*.test.ts"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.ts",
+      "!src/**/*.d.ts",
+      "!src/**/index.ts"
+    ]
+  }
+}

package/src/cli/formatter.ts

@@ -0,0 +1,63 @@
+/**
+ * Log Formatter
+ * Formats log entries for terminal display
+ */
+
+import chalk from 'chalk';
+import { format } from 'date-fns';
+import { LogEntry, LogLevel, LogSource } from '@jetstart/shared';
+import { getColorForLevel, getColorForSource } from '../utils/colors';
+
+export function formatLog(entry: LogEntry): void {
+  const timestamp = formatTimestamp(entry.timestamp);
+  const level = formatLevel(entry.level);
+  const source = formatSource(entry.source);
+  const tag = formatTag(entry.tag);
+  const message = entry.message;
+
+  console.log(`${timestamp} ${level} ${source} ${tag} ${message}`);
+}
+
+function formatTimestamp(timestamp: number): string {
+  return chalk.gray(format(timestamp, 'HH:mm:ss.SSS'));
+}
+
+function formatLevel(level: LogLevel): string {
+  const color = getColorForLevel(level);
+  const label = level.toUpperCase().padEnd(7);
+  return color(label);
+}
+
+function formatSource(source: LogSource): string {
+  const color = getColorForSource(source);
+  const label = `[${source}]`.padEnd(10);
+  return color(label);
+}
+
+function formatTag(tag: string): string {
+  return chalk.gray(`[${tag}]`);
+}
+
+export function formatStats(stats: any): void {
+  console.log();
+  console.log(chalk.bold('Log Statistics:'));
+  console.log();
+  console.log(`Total Logs:    ${chalk.cyan(stats.totalLogs)}`);
+  console.log(`Errors:        ${chalk.red(stats.errorCount)}`);
+  console.log(`Warnings:      ${chalk.yellow(stats.warningCount)}`);
+  console.log();
+  
+  console.log(chalk.bold('By Level:'));
+  Object.entries(stats.logsByLevel).forEach(([level, count]) => {
+    const color = getColorForLevel(level as LogLevel);
+    console.log(`  ${level.padEnd(10)}: ${color(count)}`);
+  });
+  
+  console.log();
+  console.log(chalk.bold('By Source:'));
+  Object.entries(stats.logsBySource).forEach(([source, count]) => {
+    const color = getColorForSource(source as LogSource);
+    console.log(`  ${source.padEnd(10)}: ${color(count)}`);
+  });
+  console.log();
+}

package/src/cli/index.ts

@@ -0,0 +1,24 @@
+/**
+ * CLI Log Viewer
+ * Terminal-based log viewer
+ */
+
+
+
+import { LogViewer } from './viewer';
+import { LogFilter } from '@jetstart/shared';
+
+export async function viewLogs(filter?: LogFilter): Promise<void> {
+  const viewer = new LogViewer();
+  await viewer.connect();
+  viewer.subscribe(filter);
+
+  // Keep process alive
+  process.on('SIGINT', async () => {
+    await viewer.disconnect();
+    process.exit(0);
+  });
+}
+
+export { LogViewer } from './viewer';
+export { formatLog } from './formatter';

package/src/cli/viewer.ts

@@ -0,0 +1,64 @@
+/**
+ * Log Viewer
+ * Connects to logs service and displays logs
+ */
+
+import WebSocket from 'ws';
+import { LogEntry, LogFilter, DEFAULT_LOGS_PORT } from '@jetstart/shared';
+import { formatLog } from './formatter';
+import chalk from 'chalk';
+
+export class LogViewer {
+  private ws?: WebSocket;
+  private connected: boolean = false;
+
+  async connect(port: number = DEFAULT_LOGS_PORT): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(`ws://localhost:${port}`);
+
+      this.ws.on('open', () => {
+        this.connected = true;
+        console.log(chalk.green('✔'), 'Connected to logs service');
+        console.log();
+        resolve();
+      });
+
+      this.ws.on('message', (data: Buffer) => {
+        try {
+          const log: LogEntry = JSON.parse(data.toString());
+          formatLog(log);
+        } catch (err) {
+          console.log(data.toString());
+        }
+      });
+
+      this.ws.on('error', (err: Error) => {
+        reject(err);
+      });
+
+      this.ws.on('close', () => {
+        this.connected = false;
+        console.log();
+        console.log(chalk.yellow('⚠'), 'Disconnected from logs service');
+      });
+    });
+  }
+
+  subscribe(filter?: LogFilter, maxLines?: number): void {
+    if (!this.ws || !this.connected) {
+      throw new Error('Not connected to logs service');
+    }
+
+    this.ws.send(JSON.stringify({
+      type: 'subscribe',
+      filter,
+      maxLines,
+    }));
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.ws) {
+      this.ws.close();
+    }
+  }
+}

package/src/filters/index.ts

@@ -0,0 +1,51 @@
+/**
+ * Log Filters
+ * Filter logs by level, source, tag, or search query
+ */
+
+
+import { LogEntry, LogFilter } from '@jetstart/shared';
+import { filterByLevel } from './level';
+import { filterBySource } from './source';
+import { filterBySearch } from './search';
+
+export function applyFilters(logs: LogEntry[], filter: LogFilter): LogEntry[] {
+  let filtered = logs;
+
+  // Filter by level
+  if (filter.levels && filter.levels.length > 0) {
+    filtered = filterByLevel(filtered, filter.levels);
+  }
+
+  // Filter by source
+  if (filter.sources && filter.sources.length > 0) {
+    filtered = filterBySource(filtered, filter.sources);
+  }
+
+  // Filter by tags
+  if (filter.tags && filter.tags.length > 0) {
+    filtered = filtered.filter(log => 
+      filter.tags!.includes(log.tag)
+    );
+  }
+
+  // Filter by search query
+  if (filter.searchQuery) {
+    filtered = filterBySearch(filtered, filter.searchQuery);
+  }
+
+  // Filter by time range
+  if (filter.startTime) {
+    filtered = filtered.filter(log => log.timestamp >= filter.startTime!);
+  }
+
+  if (filter.endTime) {
+    filtered = filtered.filter(log => log.timestamp <= filter.endTime!);
+  }
+
+  return filtered;
+}
+
+export { filterByLevel } from './level';
+export { filterBySource } from './source';
+export { filterBySearch } from './search';

package/src/filters/level.ts

@@ -0,0 +1,28 @@
+/**
+ * Level Filter
+ * Filter logs by severity level
+ */
+
+import { LogEntry, LogLevel } from '@jetstart/shared';
+
+const LEVEL_PRIORITY: Record<LogLevel, number> = {
+  [LogLevel.VERBOSE]: 0,
+  [LogLevel.DEBUG]: 1,
+  [LogLevel.INFO]: 2,
+  [LogLevel.WARN]: 3,
+  [LogLevel.ERROR]: 4,
+  [LogLevel.FATAL]: 5,
+};
+
+export function filterByLevel(logs: LogEntry[], levels: LogLevel[]): LogEntry[] {
+  return logs.filter(log => levels.includes(log.level));
+}
+
+export function filterByMinLevel(logs: LogEntry[], minLevel: LogLevel): LogEntry[] {
+  const minPriority = LEVEL_PRIORITY[minLevel];
+  
+  return logs.filter(log => {
+    const logPriority = LEVEL_PRIORITY[log.level];
+    return logPriority >= minPriority;
+  });
+}

package/src/filters/search.ts

@@ -0,0 +1,32 @@
+/**
+ * Search Filter
+ * Filter logs by text search
+ */
+
+import { LogEntry } from '@jetstart/shared';
+
+export function filterBySearch(logs: LogEntry[], query: string): LogEntry[] {
+  const lowerQuery = query.toLowerCase();
+
+  return logs.filter(log => {
+    // Search in message
+    if (log.message.toLowerCase().includes(lowerQuery)) {
+      return true;
+    }
+
+    // Search in tag
+    if (log.tag.toLowerCase().includes(lowerQuery)) {
+      return true;
+    }
+
+    // Search in metadata
+    if (log.metadata) {
+      const metadataStr = JSON.stringify(log.metadata).toLowerCase();
+      if (metadataStr.includes(lowerQuery)) {
+        return true;
+      }
+    }
+
+    return false;
+  });
+}

package/src/filters/source.ts

@@ -0,0 +1,10 @@
+/**
+ * Source Filter
+ * Filter logs by source (CLI, Core, Client, etc.)
+ */
+
+import { LogEntry, LogSource } from '@jetstart/shared';
+
+export function filterBySource(logs: LogEntry[], sources: LogSource[]): LogEntry[] {
+  return logs.filter(log => sources.includes(log.source));
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Logs Package Entry Point
+ * Logging infrastructure for JetStart
+ */
+
+export * from './server';
+export * from './cli';
+export * from './filters';
+export * from './types';
+export * from './utils';
+
+// Re-export shared log types
+export type {
+  LogEntry,
+  LogLevel,
+  LogSource,
+  LogFilter,
+  LogStats,
+} from '@jetstart/shared';

package/src/server/index.ts

@@ -0,0 +1,134 @@
+/**
+ * Logs Server
+ * WebSocket server for streaming logs
+ */
+
+import { WebSocketServer, WebSocket } from 'ws';
+import { LogStorage } from './storage';
+import { LogEntry, LogFilter, DEFAULT_LOGS_PORT } from '@jetstart/shared';
+import { applyFilters } from '../filters';
+import chalk from 'chalk';
+
+export interface LogsServerConfig {
+  port?: number;
+  maxLogEntries?: number;
+}
+
+export class LogsServer {
+  private wss?: WebSocketServer;
+  private storage: LogStorage;
+  private clients: Set<WebSocket> = new Set();
+  private config: Required<LogsServerConfig>;
+
+  constructor(config: LogsServerConfig = {}) {
+    this.config = {
+      port: config.port || DEFAULT_LOGS_PORT,
+      maxLogEntries: config.maxLogEntries || 10000,
+    };
+    this.storage = new LogStorage(this.config.maxLogEntries);
+  }
+
+  async start(): Promise<void> {
+    this.wss = new WebSocketServer({ port: this.config.port });
+
+    this.wss.on('connection', (ws: WebSocket) => {
+      console.log(chalk.green('✔'), 'Client connected to logs service');
+      this.clients.add(ws);
+
+      ws.on('message', (data: Buffer) => {
+        this.handleMessage(ws, data);
+      });
+
+      ws.on('close', () => {
+        console.log(chalk.yellow('⚠'), 'Client disconnected from logs service');
+        this.clients.delete(ws);
+      });
+
+      ws.on('error', (err: Error) => {
+        console.error(chalk.red('✖'), 'WebSocket error:', err.message);
+        this.clients.delete(ws);
+      });
+    });
+
+    console.log(chalk.cyan('[Logs]'), `Server listening on port ${this.config.port}`);
+  }
+
+  async stop(): Promise<void> {
+    if (this.wss) {
+      this.wss.close();
+      console.log(chalk.cyan('[Logs]'), 'Server stopped');
+    }
+  }
+
+  addLog(entry: LogEntry): void {
+    this.storage.add(entry);
+    this.broadcast(entry);
+  }
+
+  getLogs(filter?: LogFilter): LogEntry[] {
+    const logs = this.storage.getAll();
+    return filter ? applyFilters(logs, filter) : logs;
+  }
+
+  getStats(): any {
+    return this.storage.getStats();
+  }
+
+  private handleMessage(ws: WebSocket, data: Buffer): void {
+    try {
+      const message = JSON.parse(data.toString());
+
+      switch (message.type) {
+        case 'subscribe':
+          this.handleSubscribe(ws, message.filter, message.maxLines);
+          break;
+        case 'log':
+          this.addLog(message.log);
+          break;
+        case 'clear':
+          this.storage.clear();
+          break;
+        case 'stats':
+          this.sendStats(ws);
+          break;
+      }
+    } catch (err: any) {
+      console.error(chalk.red('✖'), 'Failed to parse message:', err.message);
+    }
+  }
+
+  private handleSubscribe(ws: WebSocket, filter?: LogFilter, maxLines?: number): void {
+    const logs = this.getLogs(filter);
+    const recentLogs = maxLines ? logs.slice(-maxLines) : logs;
+
+    // Send existing logs
+    recentLogs.forEach(log => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(log));
+      }
+    });
+  }
+
+  private broadcast(entry: LogEntry): void {
+    const data = JSON.stringify(entry);
+
+    this.clients.forEach(ws => {
+      if (ws.readyState === WebSocket.OPEN) {
+        try {
+          ws.send(data);
+        } catch (err) {
+          console.error(chalk.red('✖'), 'Failed to broadcast log');
+        }
+      }
+    });
+  }
+
+  private sendStats(ws: WebSocket): void {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({
+        type: 'stats',
+        stats: this.storage.getStats(),
+      }));
+    }
+  }
+}