@devms/livetail 0.0.2

package/dist/livetail.gateway.js

@@ -0,0 +1,334 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var LiveTailGateway_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveTailGateway = void 0;
+const common_1 = require("@nestjs/common");
+const websockets_1 = require("@nestjs/websockets");
+const socket_io_1 = require("socket.io");
+const livetail_service_1 = require("./livetail.service");
+const console_capture_service_1 = require("./console-capture.service");
+const livetail_interface_1 = require("./interfaces/livetail.interface");
+const CONSOLE_ROOM = 'console';
+/** History is replayed in chunks to keep WS frames small. */
+const CONSOLE_HISTORY_CHUNK = 500;
+/** Pending batch hard cap — oldest lines are dropped beyond this. */
+const CONSOLE_MAX_PENDING = 5000;
+let LiveTailGateway = LiveTailGateway_1 = class LiveTailGateway {
+    constructor(liveTailService, config, consoleCapture) {
+        this.liveTailService = liveTailService;
+        this.config = config;
+        this.consoleCapture = consoleCapture;
+        this.logger = new common_1.Logger(LiveTailGateway_1.name);
+        this.clients = new Map();
+        // Console streaming state
+        this.consoleSubscribers = new Set();
+        this.consolePending = [];
+        this.consoleDropped = 0;
+        this.consoleFlushTimer = null;
+    }
+    onModuleInit() {
+        if (this.config.disabled) {
+            this.logger.log('LiveTail gateway is disabled');
+            return;
+        }
+        this.subscription = this.liveTailService.logs$.subscribe((log) => {
+            this.broadcastToClients(log);
+        });
+        if (this.consoleCapture?.enabled) {
+            this.consoleSubscription = this.consoleCapture.lines$.subscribe((line) => this.queueConsoleLine(line));
+        }
+        this.logger.log('LiveTail gateway initialized');
+    }
+    onModuleDestroy() {
+        this.subscription?.unsubscribe();
+        this.consoleSubscription?.unsubscribe();
+        this.stopConsoleFlusher();
+    }
+    // ─── Connection Lifecycle ─────────────────────────────
+    handleConnection(client) {
+        // Enforce max clients limit
+        if (this.config.maxClients && this.config.maxClients > 0 && this.clients.size >= this.config.maxClients) {
+            this.logger.warn(`Connection rejected: max clients (${this.config.maxClients}) reached`);
+            client.emit('error', { message: 'Max clients limit reached. Try again later.' });
+            client.disconnect(true);
+            return;
+        }
+        this.clients.set(client.id, { filter: {}, paused: false, connectedAt: Date.now() });
+        this.logger.debug(`Client connected: ${client.id} (total: ${this.clients.size})`);
+        client.emit('connected', {
+            clientId: client.id,
+            message: 'Live tail connected',
+            connectedClients: this.clients.size,
+        });
+    }
+    handleDisconnect(client) {
+        this.clients.delete(client.id);
+        if (this.consoleSubscribers.delete(client.id)) {
+            this.stopConsoleFlusherIfIdle();
+        }
+        this.logger.debug(`Client disconnected: ${client.id} (total: ${this.clients.size})`);
+    }
+    // ─── Client Messages ─────────────────────────────────
+    /**
+     * Client subscribes with filters.
+     * Example payload:
+     * { environmentId: "xxx", level: ["error", "fatal"], category: "auth" }
+     */
+    handleSubscribe(client, filter) {
+        const state = this.clients.get(client.id);
+        if (state) {
+            state.filter = filter || {};
+            state.paused = false;
+        }
+        this.logger.debug(`Client ${client.id} subscribed: ${JSON.stringify(filter)}`);
+        client.emit('subscribed', { filter });
+    }
+    /**
+     * Client updates filters without disconnecting.
+     */
+    handleUpdateFilter(client, filter) {
+        const state = this.clients.get(client.id);
+        if (state) {
+            state.filter = filter || {};
+        }
+        client.emit('filterUpdated', { filter });
+    }
+    /**
+     * Client pauses the stream (still connected but no logs sent).
+     */
+    handlePause(client) {
+        const state = this.clients.get(client.id);
+        if (state) {
+            state.paused = true;
+        }
+        client.emit('paused');
+    }
+    /**
+     * Client resumes the stream.
+     */
+    handleResume(client) {
+        const state = this.clients.get(client.id);
+        if (state) {
+            state.paused = false;
+        }
+        client.emit('resumed');
+    }
+    // ─── Console Streaming ────────────────────────────────
+    /**
+     * Client subscribes to the raw stdout/stderr stream.
+     * Replays the ring buffer (chunked), then streams live lines
+     * batched on `console-lines` events.
+     *
+     * Payload: { token?: string, tail?: number }
+     */
+    handleSubscribeConsole(client, payload) {
+        if (!this.consoleCapture?.enabled) {
+            client.emit('console-error', {
+                code: 'CONSOLE_DISABLED',
+                message: 'Console capture is not enabled on this application. Enable it with LiveTailModule.register({ captureConsole: true }).',
+            });
+            return;
+        }
+        const requiredToken = this.consoleCapture.options.token;
+        if (requiredToken && payload?.token !== requiredToken) {
+            this.logger.warn(`Console subscribe rejected for ${client.id}: invalid token`);
+            client.emit('console-error', {
+                code: 'CONSOLE_UNAUTHORIZED',
+                message: 'Invalid or missing console token.',
+            });
+            return;
+        }
+        this.consoleSubscribers.add(client.id);
+        client.join(CONSOLE_ROOM);
+        const history = this.consoleCapture.getHistory(payload?.tail);
+        client.emit('console-subscribed', {
+            pid: process.pid,
+            bufferSize: this.consoleCapture.options.bufferSize,
+            totalCaptured: this.consoleCapture.totalCaptured,
+            historyCount: history.length,
+        });
+        // Replay history in chunks so a full buffer never becomes one giant frame
+        for (let i = 0; i < history.length; i += CONSOLE_HISTORY_CHUNK) {
+            const chunk = history.slice(i, i + CONSOLE_HISTORY_CHUNK);
+            client.emit('console-history', {
+                lines: chunk,
+                done: i + CONSOLE_HISTORY_CHUNK >= history.length,
+            });
+        }
+        if (history.length === 0) {
+            client.emit('console-history', { lines: [], done: true });
+        }
+        this.startConsoleFlusher();
+        this.logger.debug(`Client ${client.id} subscribed to console (subscribers: ${this.consoleSubscribers.size})`);
+    }
+    handleUnsubscribeConsole(client) {
+        client.leave(CONSOLE_ROOM);
+        if (this.consoleSubscribers.delete(client.id)) {
+            this.stopConsoleFlusherIfIdle();
+        }
+        client.emit('console-unsubscribed');
+    }
+    queueConsoleLine(line) {
+        // No one watching → buffer-only mode, zero broadcast cost
+        if (this.consoleSubscribers.size === 0)
+            return;
+        this.consolePending.push(line);
+        if (this.consolePending.length > CONSOLE_MAX_PENDING) {
+            const overflow = this.consolePending.length - CONSOLE_MAX_PENDING;
+            this.consolePending.splice(0, overflow);
+            this.consoleDropped += overflow;
+        }
+    }
+    flushConsolePending() {
+        if (this.consolePending.length === 0)
+            return;
+        const lines = this.consolePending;
+        this.consolePending = [];
+        const dropped = this.consoleDropped;
+        this.consoleDropped = 0;
+        this.server.to(CONSOLE_ROOM).emit('console-lines', { lines, dropped });
+    }
+    startConsoleFlusher() {
+        if (this.consoleFlushTimer)
+            return;
+        const interval = this.consoleCapture?.options.batchInterval ?? 150;
+        this.consoleFlushTimer = setInterval(() => this.flushConsolePending(), interval);
+        // Don't let the flusher keep the process alive on shutdown
+        if (typeof this.consoleFlushTimer.unref === 'function') {
+            this.consoleFlushTimer.unref();
+        }
+    }
+    stopConsoleFlusher() {
+        if (this.consoleFlushTimer) {
+            clearInterval(this.consoleFlushTimer);
+            this.consoleFlushTimer = null;
+        }
+        this.consolePending = [];
+        this.consoleDropped = 0;
+    }
+    stopConsoleFlusherIfIdle() {
+        if (this.consoleSubscribers.size === 0) {
+            this.stopConsoleFlusher();
+        }
+    }
+    // ─── Broadcasting ─────────────────────────────────────
+    broadcastToClients(log) {
+        for (const [clientId, state] of this.clients) {
+            if (state.paused)
+                continue;
+            if (!this.matchesFilter(log, state.filter))
+                continue;
+            this.server.to(clientId).emit('log', log);
+        }
+    }
+    matchesFilter(log, filter) {
+        // Scope filters
+        if (filter.environmentId && log.environmentId !== filter.environmentId)
+            return false;
+        if (filter.appId && log.appId !== filter.appId)
+            return false;
+        if (filter.orgId && log.orgId !== filter.orgId)
+            return false;
+        // Level filter (single or array)
+        if (filter.level) {
+            const levels = Array.isArray(filter.level) ? filter.level : [filter.level];
+            if (!levels.includes(log.level))
+                return false;
+        }
+        // Category filter (exact match)
+        if (filter.category && log.category !== filter.category)
+            return false;
+        // Action filter (contains, case-insensitive)
+        if (filter.action) {
+            if (!log.action.toLowerCase().includes(filter.action.toLowerCase()))
+                return false;
+        }
+        // User filter
+        if (filter.userId && log.userId !== filter.userId)
+            return false;
+        // Text search (in message, action, category)
+        if (filter.search) {
+            const term = filter.search.toLowerCase();
+            const haystack = [log.message, log.action, log.category]
+                .filter(Boolean)
+                .join(' ')
+                .toLowerCase();
+            if (!haystack.includes(term))
+                return false;
+        }
+        // Tags filter (log must have at least one matching tag)
+        if (filter.tags && filter.tags.length > 0) {
+            if (!log.tags || !filter.tags.some((t) => log.tags.includes(t)))
+                return false;
+        }
+        return true;
+    }
+};
+exports.LiveTailGateway = LiveTailGateway;
+__decorate([
+    (0, websockets_1.WebSocketServer)(),
+    __metadata("design:type", socket_io_1.Server)
+], LiveTailGateway.prototype, "server", void 0);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('subscribe'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
+    __metadata("design:returntype", void 0)
+], LiveTailGateway.prototype, "handleSubscribe", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('updateFilter'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
+    __metadata("design:returntype", void 0)
+], LiveTailGateway.prototype, "handleUpdateFilter", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('pause'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket]),
+    __metadata("design:returntype", void 0)
+], LiveTailGateway.prototype, "handlePause", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('resume'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket]),
+    __metadata("design:returntype", void 0)
+], LiveTailGateway.prototype, "handleResume", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('subscribe-console'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
+    __metadata("design:returntype", void 0)
+], LiveTailGateway.prototype, "handleSubscribeConsole", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('unsubscribe-console'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket]),
+    __metadata("design:returntype", void 0)
+], LiveTailGateway.prototype, "handleUnsubscribeConsole", null);
+exports.LiveTailGateway = LiveTailGateway = LiveTailGateway_1 = __decorate([
+    (0, websockets_1.WebSocketGateway)({ namespace: '/live-tail', cors: { origin: '*' } }),
+    __param(1, (0, common_1.Inject)(livetail_interface_1.LIVETAIL_CONFIG)),
+    __param(2, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [livetail_service_1.LiveTailService, Object, console_capture_service_1.ConsoleCaptureService])
+], LiveTailGateway);

package/dist/livetail.module.d.ts

@@ -0,0 +1,52 @@
+import { DynamicModule } from '@nestjs/common';
+import { LiveTailConfig } from './interfaces/livetail.interface';
+export declare class LiveTailModule {
+    /**
+     * Register the live tail module with static config.
+     *
+     * @example
+     * // Default (all options)
+     * LiveTailModule.register()
+     *
+     * @example
+     * // Custom configuration
+     * LiveTailModule.register({
+     *   cors: ['https://dashboard.example.com'],
+     *   maxClients: 100,
+     * })
+     *
+     * @example
+     * // Disable in specific environments
+     * LiveTailModule.register({
+     *   disabled: process.env.NODE_ENV === 'test',
+     * })
+     *
+     * @example
+     * // Stream raw stdout/stderr (terminal console) to the dashboard
+     * LiveTailModule.register({
+     *   captureConsole: {
+     *     bufferSize: 2000,
+     *     token: process.env.LIVETAIL_CONSOLE_TOKEN,
+     *   },
+     * })
+     */
+    static register(config?: LiveTailConfig): DynamicModule;
+    /**
+     * Register the live tail module with async config (e.g. from ConfigService).
+     *
+     * @example
+     * LiveTailModule.registerAsync({
+     *   inject: [ConfigService],
+     *   useFactory: (config: ConfigService) => ({
+     *     cors: config.get('LIVETAIL_CORS_ORIGIN', '*'),
+     *     maxClients: parseInt(config.get('LIVETAIL_MAX_CLIENTS', '0')),
+     *     disabled: config.get('LIVETAIL_DISABLED') === 'true',
+     *   }),
+     * })
+     */
+    static registerAsync(options: {
+        inject?: any[];
+        useFactory: (...args: any[]) => LiveTailConfig | Promise<LiveTailConfig>;
+        imports?: any[];
+    }): DynamicModule;
+}

package/dist/livetail.module.js

@@ -0,0 +1,105 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var LiveTailModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveTailModule = void 0;
+const common_1 = require("@nestjs/common");
+const livetail_interface_1 = require("./interfaces/livetail.interface");
+const livetail_service_1 = require("./livetail.service");
+const livetail_gateway_1 = require("./livetail.gateway");
+const console_capture_service_1 = require("./console-capture.service");
+const DEFAULT_CONFIG = {
+    namespace: '/live-tail',
+    cors: '*',
+    maxClients: 0,
+    pingInterval: 25000,
+    pingTimeout: 20000,
+    disabled: false,
+};
+let LiveTailModule = LiveTailModule_1 = class LiveTailModule {
+    /**
+     * Register the live tail module with static config.
+     *
+     * @example
+     * // Default (all options)
+     * LiveTailModule.register()
+     *
+     * @example
+     * // Custom configuration
+     * LiveTailModule.register({
+     *   cors: ['https://dashboard.example.com'],
+     *   maxClients: 100,
+     * })
+     *
+     * @example
+     * // Disable in specific environments
+     * LiveTailModule.register({
+     *   disabled: process.env.NODE_ENV === 'test',
+     * })
+     *
+     * @example
+     * // Stream raw stdout/stderr (terminal console) to the dashboard
+     * LiveTailModule.register({
+     *   captureConsole: {
+     *     bufferSize: 2000,
+     *     token: process.env.LIVETAIL_CONSOLE_TOKEN,
+     *   },
+     * })
+     */
+    static register(config) {
+        const merged = { ...DEFAULT_CONFIG, ...config };
+        return {
+            module: LiveTailModule_1,
+            providers: [
+                { provide: livetail_interface_1.LIVETAIL_CONFIG, useValue: merged },
+                livetail_service_1.LiveTailService,
+                console_capture_service_1.ConsoleCaptureService,
+                ...(merged.disabled ? [] : [livetail_gateway_1.LiveTailGateway]),
+            ],
+            exports: [livetail_service_1.LiveTailService, console_capture_service_1.ConsoleCaptureService],
+        };
+    }
+    /**
+     * Register the live tail module with async config (e.g. from ConfigService).
+     *
+     * @example
+     * LiveTailModule.registerAsync({
+     *   inject: [ConfigService],
+     *   useFactory: (config: ConfigService) => ({
+     *     cors: config.get('LIVETAIL_CORS_ORIGIN', '*'),
+     *     maxClients: parseInt(config.get('LIVETAIL_MAX_CLIENTS', '0')),
+     *     disabled: config.get('LIVETAIL_DISABLED') === 'true',
+     *   }),
+     * })
+     */
+    static registerAsync(options) {
+        return {
+            module: LiveTailModule_1,
+            imports: [...(options.imports || [])],
+            providers: [
+                {
+                    provide: livetail_interface_1.LIVETAIL_CONFIG,
+                    inject: options.inject || [],
+                    useFactory: async (...args) => {
+                        const config = await options.useFactory(...args);
+                        return { ...DEFAULT_CONFIG, ...config };
+                    },
+                },
+                livetail_service_1.LiveTailService,
+                console_capture_service_1.ConsoleCaptureService,
+                livetail_gateway_1.LiveTailGateway,
+            ],
+            exports: [livetail_service_1.LiveTailService, console_capture_service_1.ConsoleCaptureService],
+        };
+    }
+};
+exports.LiveTailModule = LiveTailModule;
+exports.LiveTailModule = LiveTailModule = LiveTailModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], LiveTailModule);

package/dist/livetail.service.d.ts

@@ -0,0 +1,38 @@
+import { Observable } from 'rxjs';
+import { LiveTailConfig, LiveTailEnvContext, LiveTailLogEvent } from './interfaces/livetail.interface';
+export declare class LiveTailService {
+    private readonly logSubject;
+    private readonly isDisabled;
+    constructor(config?: LiveTailConfig);
+    /**
+     * Observable stream of all log events.
+     * The gateway subscribes to this to broadcast to connected clients.
+     */
+    get logs$(): Observable<LiveTailLogEvent>;
+    /**
+     * Broadcast a single log event to all connected live tail clients.
+     * Call this after persisting the log to the database.
+     *
+     * @param log  The log event to broadcast.
+     * @param ctx  Optional environment context to enrich the log with org/app/env info.
+     *
+     * @example
+     * this.liveTailService.broadcast(logData, {
+     *   environmentId: env.id,
+     *   envName: env.name,
+     *   appId: app.id,
+     *   appName: app.name,
+     *   orgId: org.id,
+     *   orgName: org.name,
+     * });
+     */
+    broadcast(log: LiveTailLogEvent, ctx?: LiveTailEnvContext): void;
+    /**
+     * Broadcast multiple log events at once.
+     *
+     * @param logs Array of log events.
+     * @param ctx  Optional environment context to enrich all logs.
+     */
+    broadcastMany(logs: LiveTailLogEvent[], ctx?: LiveTailEnvContext): void;
+    private enrichLog;
+}

package/dist/livetail.service.js

@@ -0,0 +1,84 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveTailService = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const livetail_interface_1 = require("./interfaces/livetail.interface");
+let LiveTailService = class LiveTailService {
+    constructor(config) {
+        this.logSubject = new rxjs_1.Subject();
+        this.isDisabled = config?.disabled ?? false;
+    }
+    /**
+     * Observable stream of all log events.
+     * The gateway subscribes to this to broadcast to connected clients.
+     */
+    get logs$() {
+        return this.logSubject.asObservable();
+    }
+    /**
+     * Broadcast a single log event to all connected live tail clients.
+     * Call this after persisting the log to the database.
+     *
+     * @param log  The log event to broadcast.
+     * @param ctx  Optional environment context to enrich the log with org/app/env info.
+     *
+     * @example
+     * this.liveTailService.broadcast(logData, {
+     *   environmentId: env.id,
+     *   envName: env.name,
+     *   appId: app.id,
+     *   appName: app.name,
+     *   orgId: org.id,
+     *   orgName: org.name,
+     * });
+     */
+    broadcast(log, ctx) {
+        if (this.isDisabled)
+            return;
+        this.logSubject.next(ctx ? this.enrichLog(log, ctx) : log);
+    }
+    /**
+     * Broadcast multiple log events at once.
+     *
+     * @param logs Array of log events.
+     * @param ctx  Optional environment context to enrich all logs.
+     */
+    broadcastMany(logs, ctx) {
+        if (this.isDisabled)
+            return;
+        for (const log of logs) {
+            this.logSubject.next(ctx ? this.enrichLog(log, ctx) : log);
+        }
+    }
+    enrichLog(log, ctx) {
+        return {
+            ...log,
+            environmentId: log.environmentId || ctx.environmentId,
+            envName: log.envName || ctx.envName,
+            appId: log.appId || ctx.appId,
+            appName: log.appName || ctx.appName,
+            orgId: log.orgId || ctx.orgId,
+            orgName: log.orgName || ctx.orgName,
+        };
+    }
+};
+exports.LiveTailService = LiveTailService;
+exports.LiveTailService = LiveTailService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(livetail_interface_1.LIVETAIL_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], LiveTailService);

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@devms/livetail",
+  "version": "0.0.2",
+  "description": "NestJS WebSocket live tail module for real-time log streaming. Integrates with any NestJS application to broadcast logs via Socket.IO.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "tsc"
+  },
+  "keywords": [
+    "nestjs",
+    "websocket",
+    "live-tail",
+    "logging",
+    "real-time",
+    "socket.io",
+    "monitoring",
+    "observability"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/websockets": "^10.0.0 || ^11.0.0",
+    "@nestjs/platform-socket.io": "^10.0.0 || ^11.0.0",
+    "rxjs": "^7.0.0"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.1.3",
+    "@nestjs/core": "^11.1.3",
+    "@nestjs/websockets": "^11.0.0",
+    "@nestjs/platform-socket.io": "^11.0.0",
+    "@types/node": "^24.0.0",
+    "rxjs": "^7.8.2",
+    "socket.io": "^4.8.0",
+    "typescript": "^5.8.3"
+  }
+}