@jetstart/logs 1.5.2

package/.eslintrc.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../.eslintrc.json",
+  "parserOptions": {
+    "project": ["./tsconfig.json", "./tsconfig.tests.json"]
+  }
+}

package/README.md

@@ -0,0 +1,122 @@
+# @jetstart/logs
+
+Logging infrastructure for JetStart.
+
+## Overview
+
+The Logs package provides:
+
+- 📊 **Log Server** - WebSocket-based log streaming
+- 💾 **Log Storage** - In-memory log storage with size limits
+- 🔍 **Filtering** - Filter by level, source, tag, or search query
+- 🖥️ **CLI Viewer** - Terminal-based log viewer
+- 📈 **Statistics** - Log metrics and analytics
+
+## Usage
+
+### Start Log Server
+```typescript
+import { LogsServer } from '@jetstart/logs';
+
+const server = new LogsServer({ port: 8767 });
+await server.start();
+```
+
+### View Logs in CLI
+```typescript
+import { viewLogs } from '@jetstart/logs';
+import { LogLevel, LogSource } from '@jetstart/shared';
+
+await viewLogs({
+  levels: [LogLevel.ERROR, LogLevel.WARN],
+  sources: [LogSource.BUILD],
+});
+```
+
+### Add Logs
+```typescript
+import { LogsServer } from '@jetstart/logs';
+import { LogLevel, LogSource } from '@jetstart/shared';
+
+const server = new LogsServer();
+await server.start();
+
+server.addLog({
+  id: '123',
+  timestamp: Date.now(),
+  level: LogLevel.INFO,
+  tag: 'Build',
+  message: 'Compilation complete',
+  source: LogSource.BUILD,
+});
+```
+
+### Filter Logs
+```typescript
+import { applyFilters } from '@jetstart/logs';
+import { LogLevel } from '@jetstart/shared';
+
+const filtered = applyFilters(logs, {
+  levels: [LogLevel.ERROR],
+  searchQuery: 'compilation',
+  startTime: Date.now() - 3600000, // Last hour
+});
+```
+
+## Log Levels
+
+- `VERBOSE` - Very detailed information
+- `DEBUG` - Debug information
+- `INFO` - General information
+- `WARN` - Warning messages
+- `ERROR` - Error messages
+- `FATAL` - Fatal errors
+
+## Log Sources
+
+- `CLI` - Command-line interface
+- `CORE` - Build server
+- `CLIENT` - Android client
+- `BUILD` - Build system
+- `NETWORK` - Network operations
+- `SYSTEM` - System operations
+
+## WebSocket Protocol
+
+**Subscribe to logs:**
+```json
+{
+  "type": "subscribe",
+  "filter": {
+    "levels": ["error", "warn"],
+    "sources": ["build"]
+  },
+  "maxLines": 100
+}
+```
+
+**Send log:**
+```json
+{
+  "type": "log",
+  "log": {
+    "id": "123",
+    "timestamp": 1234567890,
+    "level": "info",
+    "tag": "Build",
+    "message": "Build complete",
+    "source": "build"
+  }
+}
+```
+
+**Get statistics:**
+```json
+{
+  "type": "stats"
+}
+```
+
+## License
+
+Apache-2.0

package/dist/cli/formatter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Log Formatter
+ * Formats log entries for terminal display
+ */
+import { LogEntry } from '@jetstart/shared';
+export declare function formatLog(entry: LogEntry): void;
+export declare function formatStats(stats: any): void;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/cli/formatter.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Log Formatter
+ * Formats log entries for terminal display
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLog = formatLog;
+exports.formatStats = formatStats;
+const chalk_1 = __importDefault(require("chalk"));
+const date_fns_1 = require("date-fns");
+const colors_1 = require("../utils/colors");
+function formatLog(entry) {
+    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) {
+    return chalk_1.default.gray((0, date_fns_1.format)(timestamp, 'HH:mm:ss.SSS'));
+}
+function formatLevel(level) {
+    const color = (0, colors_1.getColorForLevel)(level);
+    const label = level.toUpperCase().padEnd(7);
+    return color(label);
+}
+function formatSource(source) {
+    const color = (0, colors_1.getColorForSource)(source);
+    const label = `[${source}]`.padEnd(10);
+    return color(label);
+}
+function formatTag(tag) {
+    return chalk_1.default.gray(`[${tag}]`);
+}
+function formatStats(stats) {
+    console.log();
+    console.log(chalk_1.default.bold('Log Statistics:'));
+    console.log();
+    console.log(`Total Logs:    ${chalk_1.default.cyan(stats.totalLogs)}`);
+    console.log(`Errors:        ${chalk_1.default.red(stats.errorCount)}`);
+    console.log(`Warnings:      ${chalk_1.default.yellow(stats.warningCount)}`);
+    console.log();
+    console.log(chalk_1.default.bold('By Level:'));
+    Object.entries(stats.logsByLevel).forEach(([level, count]) => {
+        const color = (0, colors_1.getColorForLevel)(level);
+        console.log(`  ${level.padEnd(10)}: ${color(count)}`);
+    });
+    console.log();
+    console.log(chalk_1.default.bold('By Source:'));
+    Object.entries(stats.logsBySource).forEach(([source, count]) => {
+        const color = (0, colors_1.getColorForSource)(source);
+        console.log(`  ${source.padEnd(10)}: ${color(count)}`);
+    });
+    console.log();
+}
+//# sourceMappingURL=formatter.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CLI Log Viewer
+ * Terminal-based log viewer
+ */
+import { LogFilter } from '@jetstart/shared';
+export declare function viewLogs(filter?: LogFilter): Promise<void>;
+export { LogViewer } from './viewer';
+export { formatLog } from './formatter';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * CLI Log Viewer
+ * Terminal-based log viewer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLog = exports.LogViewer = void 0;
+exports.viewLogs = viewLogs;
+const viewer_1 = require("./viewer");
+async function viewLogs(filter) {
+    const viewer = new viewer_1.LogViewer();
+    await viewer.connect();
+    viewer.subscribe(filter);
+    // Keep process alive
+    process.on('SIGINT', async () => {
+        await viewer.disconnect();
+        process.exit(0);
+    });
+}
+var viewer_2 = require("./viewer");
+Object.defineProperty(exports, "LogViewer", { enumerable: true, get: function () { return viewer_2.LogViewer; } });
+var formatter_1 = require("./formatter");
+Object.defineProperty(exports, "formatLog", { enumerable: true, get: function () { return formatter_1.formatLog; } });
+//# sourceMappingURL=index.js.map

package/dist/cli/viewer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Log Viewer
+ * Connects to logs service and displays logs
+ */
+import { LogFilter } from '@jetstart/shared';
+export declare class LogViewer {
+    private ws?;
+    private connected;
+    connect(port?: number): Promise<void>;
+    subscribe(filter?: LogFilter, maxLines?: number): void;
+    disconnect(): Promise<void>;
+}
+//# sourceMappingURL=viewer.d.ts.map

package/dist/cli/viewer.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Log Viewer
+ * Connects to logs service and displays logs
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogViewer = void 0;
+const ws_1 = __importDefault(require("ws"));
+const shared_1 = require("@jetstart/shared");
+const formatter_1 = require("./formatter");
+const chalk_1 = __importDefault(require("chalk"));
+class LogViewer {
+    ws;
+    connected = false;
+    async connect(port = shared_1.DEFAULT_LOGS_PORT) {
+        return new Promise((resolve, reject) => {
+            this.ws = new ws_1.default(`ws://localhost:${port}`);
+            this.ws.on('open', () => {
+                this.connected = true;
+                console.log(chalk_1.default.green('✔'), 'Connected to logs service');
+                console.log();
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const log = JSON.parse(data.toString());
+                    (0, formatter_1.formatLog)(log);
+                }
+                catch (err) {
+                    console.log(data.toString());
+                }
+            });
+            this.ws.on('error', (err) => {
+                reject(err);
+            });
+            this.ws.on('close', () => {
+                this.connected = false;
+                console.log();
+                console.log(chalk_1.default.yellow('⚠'), 'Disconnected from logs service');
+            });
+        });
+    }
+    subscribe(filter, maxLines) {
+        if (!this.ws || !this.connected) {
+            throw new Error('Not connected to logs service');
+        }
+        this.ws.send(JSON.stringify({
+            type: 'subscribe',
+            filter,
+            maxLines,
+        }));
+    }
+    async disconnect() {
+        if (this.ws) {
+            this.ws.close();
+        }
+    }
+}
+exports.LogViewer = LogViewer;
+//# sourceMappingURL=viewer.js.map

package/dist/filters/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Log Filters
+ * Filter logs by level, source, tag, or search query
+ */
+import { LogEntry, LogFilter } from '@jetstart/shared';
+export declare function applyFilters(logs: LogEntry[], filter: LogFilter): LogEntry[];
+export { filterByLevel } from './level';
+export { filterBySource } from './source';
+export { filterBySearch } from './search';
+//# sourceMappingURL=index.d.ts.map

package/dist/filters/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Log Filters
+ * Filter logs by level, source, tag, or search query
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterBySearch = exports.filterBySource = exports.filterByLevel = void 0;
+exports.applyFilters = applyFilters;
+const level_1 = require("./level");
+const source_1 = require("./source");
+const search_1 = require("./search");
+function applyFilters(logs, filter) {
+    let filtered = logs;
+    // Filter by level
+    if (filter.levels && filter.levels.length > 0) {
+        filtered = (0, level_1.filterByLevel)(filtered, filter.levels);
+    }
+    // Filter by source
+    if (filter.sources && filter.sources.length > 0) {
+        filtered = (0, source_1.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 = (0, search_1.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;
+}
+var level_2 = require("./level");
+Object.defineProperty(exports, "filterByLevel", { enumerable: true, get: function () { return level_2.filterByLevel; } });
+var source_2 = require("./source");
+Object.defineProperty(exports, "filterBySource", { enumerable: true, get: function () { return source_2.filterBySource; } });
+var search_2 = require("./search");
+Object.defineProperty(exports, "filterBySearch", { enumerable: true, get: function () { return search_2.filterBySearch; } });
+//# sourceMappingURL=index.js.map

package/dist/filters/level.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Level Filter
+ * Filter logs by severity level
+ */
+import { LogEntry, LogLevel } from '@jetstart/shared';
+export declare function filterByLevel(logs: LogEntry[], levels: LogLevel[]): LogEntry[];
+export declare function filterByMinLevel(logs: LogEntry[], minLevel: LogLevel): LogEntry[];
+//# sourceMappingURL=level.d.ts.map

package/dist/filters/level.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Level Filter
+ * Filter logs by severity level
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterByLevel = filterByLevel;
+exports.filterByMinLevel = filterByMinLevel;
+const shared_1 = require("@jetstart/shared");
+const LEVEL_PRIORITY = {
+    [shared_1.LogLevel.VERBOSE]: 0,
+    [shared_1.LogLevel.DEBUG]: 1,
+    [shared_1.LogLevel.INFO]: 2,
+    [shared_1.LogLevel.WARN]: 3,
+    [shared_1.LogLevel.ERROR]: 4,
+    [shared_1.LogLevel.FATAL]: 5,
+};
+function filterByLevel(logs, levels) {
+    return logs.filter(log => levels.includes(log.level));
+}
+function filterByMinLevel(logs, minLevel) {
+    const minPriority = LEVEL_PRIORITY[minLevel];
+    return logs.filter(log => {
+        const logPriority = LEVEL_PRIORITY[log.level];
+        return logPriority >= minPriority;
+    });
+}
+//# sourceMappingURL=level.js.map

package/dist/filters/search.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Search Filter
+ * Filter logs by text search
+ */
+import { LogEntry } from '@jetstart/shared';
+export declare function filterBySearch(logs: LogEntry[], query: string): LogEntry[];
+//# sourceMappingURL=search.d.ts.map

package/dist/filters/search.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Search Filter
+ * Filter logs by text search
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterBySearch = filterBySearch;
+function filterBySearch(logs, query) {
+    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;
+    });
+}
+//# sourceMappingURL=search.js.map

package/dist/filters/source.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Source Filter
+ * Filter logs by source (CLI, Core, Client, etc.)
+ */
+import { LogEntry, LogSource } from '@jetstart/shared';
+export declare function filterBySource(logs: LogEntry[], sources: LogSource[]): LogEntry[];
+//# sourceMappingURL=source.d.ts.map

package/dist/filters/source.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Source Filter
+ * Filter logs by source (CLI, Core, Client, etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterBySource = filterBySource;
+function filterBySource(logs, sources) {
+    return logs.filter(log => sources.includes(log.source));
+}
+//# sourceMappingURL=source.js.map

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Logs Package Entry Point
+ * Logging infrastructure for JetStart
+ */
+export * from './server';
+export * from './cli';
+export * from './filters';
+export * from './types';
+export * from './utils';
+export type { LogEntry, LogLevel, LogSource, LogFilter, LogStats, } from '@jetstart/shared';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Logs Package Entry Point
+ * Logging infrastructure for JetStart
+ */
+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("./server"), exports);
+__exportStar(require("./cli"), exports);
+__exportStar(require("./filters"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=index.js.map

package/dist/server/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Logs Server
+ * WebSocket server for streaming logs
+ */
+import { LogEntry, LogFilter } from '@jetstart/shared';
+export interface LogsServerConfig {
+    port?: number;
+    maxLogEntries?: number;
+}
+export declare class LogsServer {
+    private wss?;
+    private storage;
+    private clients;
+    private config;
+    constructor(config?: LogsServerConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    addLog(entry: LogEntry): void;
+    getLogs(filter?: LogFilter): LogEntry[];
+    getStats(): any;
+    private handleMessage;
+    private handleSubscribe;
+    private broadcast;
+    private sendStats;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Logs Server
+ * WebSocket server for streaming logs
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogsServer = void 0;
+const ws_1 = require("ws");
+const storage_1 = require("./storage");
+const shared_1 = require("@jetstart/shared");
+const filters_1 = require("../filters");
+const chalk_1 = __importDefault(require("chalk"));
+class LogsServer {
+    wss;
+    storage;
+    clients = new Set();
+    config;
+    constructor(config = {}) {
+        this.config = {
+            port: config.port || shared_1.DEFAULT_LOGS_PORT,
+            maxLogEntries: config.maxLogEntries || 10000,
+        };
+        this.storage = new storage_1.LogStorage(this.config.maxLogEntries);
+    }
+    async start() {
+        this.wss = new ws_1.WebSocketServer({ port: this.config.port });
+        this.wss.on('connection', (ws) => {
+            console.log(chalk_1.default.green('✔'), 'Client connected to logs service');
+            this.clients.add(ws);
+            ws.on('message', (data) => {
+                this.handleMessage(ws, data);
+            });
+            ws.on('close', () => {
+                console.log(chalk_1.default.yellow('⚠'), 'Client disconnected from logs service');
+                this.clients.delete(ws);
+            });
+            ws.on('error', (err) => {
+                console.error(chalk_1.default.red('✖'), 'WebSocket error:', err.message);
+                this.clients.delete(ws);
+            });
+        });
+        console.log(chalk_1.default.cyan('[Logs]'), `Server listening on port ${this.config.port}`);
+    }
+    async stop() {
+        if (this.wss) {
+            this.wss.close();
+            console.log(chalk_1.default.cyan('[Logs]'), 'Server stopped');
+        }
+    }
+    addLog(entry) {
+        this.storage.add(entry);
+        this.broadcast(entry);
+    }
+    getLogs(filter) {
+        const logs = this.storage.getAll();
+        return filter ? (0, filters_1.applyFilters)(logs, filter) : logs;
+    }
+    getStats() {
+        return this.storage.getStats();
+    }
+    handleMessage(ws, data) {
+        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) {
+            console.error(chalk_1.default.red('✖'), 'Failed to parse message:', err.message);
+        }
+    }
+    handleSubscribe(ws, filter, maxLines) {
+        const logs = this.getLogs(filter);
+        const recentLogs = maxLines ? logs.slice(-maxLines) : logs;
+        // Send existing logs
+        recentLogs.forEach(log => {
+            if (ws.readyState === ws_1.WebSocket.OPEN) {
+                ws.send(JSON.stringify(log));
+            }
+        });
+    }
+    broadcast(entry) {
+        const data = JSON.stringify(entry);
+        this.clients.forEach(ws => {
+            if (ws.readyState === ws_1.WebSocket.OPEN) {
+                try {
+                    ws.send(data);
+                }
+                catch (err) {
+                    console.error(chalk_1.default.red('✖'), 'Failed to broadcast log');
+                }
+            }
+        });
+    }
+    sendStats(ws) {
+        if (ws.readyState === ws_1.WebSocket.OPEN) {
+            ws.send(JSON.stringify({
+                type: 'stats',
+                stats: this.storage.getStats(),
+            }));
+        }
+    }
+}
+exports.LogsServer = LogsServer;
+//# sourceMappingURL=index.js.map

package/dist/server/storage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Log Storage
+ * In-memory log storage with size limits
+ */
+import { LogEntry, LogStats } from '@jetstart/shared';
+export declare class LogStorage {
+    private logs;
+    private maxEntries;
+    constructor(maxEntries?: number);
+    add(entry: LogEntry): void;
+    getAll(): LogEntry[];
+    clear(): void;
+    getStats(): LogStats;
+}
+//# sourceMappingURL=storage.d.ts.map